In diesem Beitrag wird beschrieben, wie man verschiedene Medien (Bilder, Filme, Audio) hochladen, in einer Datenbank speichern und (mit HTML 5) wieder darstellen kann. Ich gehe aus von einer frisch erstellten und herausgeputzten MVC 3 Webapplikation.

Am Schluss sollte die Liste in etwa so aussehen:

M wie Model

Mein Model speichert einen Namen, den Content- (oder MIME-) Type und die binären Daten des Mediums. Aus dem folgenden Model macht das Entity-Framework ein erstaunlich gutes SQL-Schema:
[cc lang="C#"]
// Sie ist ein Model und sie sieht gut aus…
namespace MediaPOC.Models {
public class Media {

public virtual int MediaId { get; set; }
[Required]
[StringLength(150)]
public virtual string Name { get; set; }
[Required]
[StringLength(250)]
[ScaffoldColumn(false)]
public virtual string MimeType { get; set; }
[Required]
public virtual byte[] Data { get; set; }
}
}
[/cc]

Daraus kann man nun den Rest mal scaffolden. Das Produkt wird aber noch nicht ganz funktionieren, da sich MVC 3 keinen Reim auf das “Data” Feld machen kann.

V wie View

Der grundsätzliche Trick besteht darin, dem file-upload-Tag einen anderen Namen zu geben um so die Datei ganz kontrolliert im Model abspeichern zu können. Ebenfalls muss der Form-Tag für den Upload angepasst werden. Die wichtigen Teile von Create.cshtml (und ev. auch Edit.cshtml):
[cc lang="html"]
@using (Html.BeginForm(null, null, FormMethod.Post, new { enctype = “multipart/form-data” })) {
@Html.ValidationSummary(true)

}
[/cc]

C wie Controller

Die Datei wird dem Controller als zusätzliches Argument übergeben. Ein Grundproblem ist, dass das Model wegen dem leeren Date ungültig ist. Ein Revalidate nach dem Speichern der Daten besänftigen die MS-Götter:
[cc lang="C#"]
//
// POST: /Home/Create

[HttpPost]
public ActionResult Create(Media media, HttpPostedFileBase file)
{
// Do we have a file
if (file != null && file.ContentLength > 0)
{ // Yes
media.MimeType = file.ContentType;
media.Data = new byte[file.ContentLength];
file.InputStream.Read(media.Data, 0, file.ContentLength);
}
// If a file was supplied, we have saved the data in teh model
ModelState.Clear();
TryValidateModel(media);
if (ModelState.IsValid)
{
db.Media.Add(media);
db.SaveChanges();
return RedirectToAction(“Index”);
}

return View(media);
}
[/cc]

Und das wars schon.

Moment, wie kriegen wir die Daten wieder raus?

Nun, äääähm, ja. Ganz grundsätzlich braucht es sicher eine Möglichkeit, die Daten dem Browser zu senden. Die folgende Lösung ist einfach und nett, hat allerdings ein Problem: Der Dateiname bei einem Download ist hässlich.
[cc lang="C#"]
namespace MediaPOC.Controllers {
public class MediaController : Controller {
private MediaPOCContext db = new MediaPOCContext();

//
// GET: /Media/Show/5
public ActionResult Show(int id) {
Media media = db.Media.Find(id);
return File(media.Data, media.MimeType);
}
}
}
[/cc]

Um in den Views locker zu bleiben habe ich mir HTML5 zu Hilfe geholt. Ein View-Helper soll jeweils einen korrekten Media-Tag und ein Link darstellen. Bei Audio/Video wird das Element unsichtbar gemacht, bis man sich sicher ist, dass der Browser das Format beherrscht. Das Format des Mediums wird beim Tag in einem data-type Attribut gespeichert. Angewendet wird der Tag in einer View mittels:
[cc lang="HTML"]
@Html.MediaTag(mediaObject)
[/cc]

Ich weiss, der Code ist leicht redundant, aber ich wollte Audio und Video aus irgendeinem ganz wichtigen Grund, den ich vergessen habe, trennen:
[cc lang="C#"]
namespace MediaPOC.Helpers {
public static class HtmlHelpers {
public static MvcHtmlString MediaTag(this HtmlHelper helper, Media media, int thumbnailsize=50) {
UrlHelper urlHelper = new UrlHelper(helper.ViewContext.RequestContext);
string url = urlHelper.Action(“Show”, “Media”, new { id = media.MediaId });

TagBuilder mediaTag;
TagBuilder brTag= new TagBuilder(“br”);

string tag=”";

if(media.MimeType==”image/png” || media.MimeType==”image/gif” || media.MimeType== “image/jpeg”) {
TagBuilder imageTag = new TagBuilder(“img”);
imageTag.MergeAttribute(“src”, url);
imageTag.MergeAttribute(“class”, “thumbnail”);

mediaTag = new TagBuilder(“a”);
mediaTag.MergeAttribute(“href”, url);
mediaTag.InnerHtml = imageTag.ToString();
tag=mediaTag.ToString(TagRenderMode.Normal);

}
else if (media.MimeType.StartsWith(“audio/”))
{

TagBuilder aTag = new TagBuilder(“a”);
aTag.MergeAttribute(“href”, url);
aTag.InnerHtml = media.Name;

mediaTag = new TagBuilder(“audio”);
mediaTag.MergeAttribute(“data-type”, media.MimeType);
mediaTag.MergeAttribute(“style”, “display:none”);
mediaTag.MergeAttribute(“class”, “thumbnail”);
mediaTag.MergeAttribute(“src”, url);
mediaTag.MergeAttribute(“controls”, “controls”);
mediaTag.InnerHtml = aTag.ToString();
tag = mediaTag.ToString(TagRenderMode.Normal) + brTag.ToString()+aTag.ToString();

}
else if (media.MimeType.StartsWith(“video/”))
{

TagBuilder aTag = new TagBuilder(“a”);
aTag.MergeAttribute(“href”, url);
aTag.InnerHtml = media.Name;

mediaTag = new TagBuilder(“video”);
mediaTag.MergeAttribute(“data-type”, media.MimeType);
mediaTag.MergeAttribute(“style”, “display:none”);
mediaTag.MergeAttribute(“class”, “thumbnail”);

mediaTag.MergeAttribute(“src”, url);
mediaTag.MergeAttribute(“controls”, “controls”);
mediaTag.InnerHtml = aTag.ToString();
tag = mediaTag.ToString(TagRenderMode.Normal) + brTag.ToString() + aTag.ToString();

}
else
{
mediaTag = new TagBuilder(“a”);
mediaTag.SetInnerText(media.Name);
mediaTag.MergeAttribute(“href”, url);
tag = mediaTag.ToString(TagRenderMode.Normal);
}

return new MvcHtmlString(tag);
}
}//end of class
}//end of namespace
[/cc]

Um die entsprechenden Elemente sichtbar zu machen, wenn der Browser sie beherrscht, muss man noch etwas JavaScript absondern:
[cc lang="JavaScript"]
$(function () {
$(“audio”).each(function (index) {

var audioElement = document.createElement(‘audio’);
var canPlayType = audioElement.canPlayType($(this).attr(‘data-type’));

if (canPlayType.match(/maybe|probably/i)) {
$(this).show();
}

});
$(“video”).each(function (index) {

var videoElement = document.createElement(‘video’);
var canPlayType = videoElement.canPlayType($(this).attr(‘data-type’));

if (canPlayType.match(/maybe|probably/i)) {
$(this).show();
}

});
});
[/cc]

So, das wars. Super.

…Hier würde etwas Musik gespielt und ein Countdown eingeblendet werden, damit der interessierte Leser eine Lösung erarbeiten kann …

Meine Lösung funktioniert, sofern die Symbole im Alphabet einem Symbol in UTF-8 entsprechen und ist trivial: Zuerst werden alle Permutationen gebildet und der RegExp daran getestet. Aus reinem Masochismus habe ich versucht, dies in Python 3.2 zu implementieren. Und nein, itertools packt das nicht!

Ein Testdurchgang könnte folgendermassen aussehen (Das Alphabet besteht aus 0 und 1):

$ python3.2 msfr.py -v '(0*|1*)(0*|1*)(0*|1*)' 0 1
Σ: {0, 1}
  Testing: '^(0*|1*)(0*|1*)(0*|1*)$' with ε MATCH
  Testing: '^(0*|1*)(0*|1*)(0*|1*)$' with 0 MATCH
  Testing: '^(0*|1*)(0*|1*)(0*|1*)$' with 1 MATCH
  Testing: '^(0*|1*)(0*|1*)(0*|1*)$' with 00 MATCH
[...]
  Testing: '^(0*|1*)(0*|1*)(0*|1*)$' with 0011 MATCH
  Testing: '^(0*|1*)(0*|1*)(0*|1*)$' with 0100 MATCH
  Testing: '^(0*|1*)(0*|1*)(0*|1*)$' with 0101 NOMATCH
  Testing: '^(0*|1*)(0*|1*)(0*|1*)$' with 0110 MATCH
[...]
  Testing: '^(0*|1*)(0*|1*)(0*|1*)$' with 1010 NOMATCH
  Testing: '^(0*|1*)(0*|1*)(0*|1*)$' with 1011 MATCH
[...]
  Testing: '^(0*|1*)(0*|1*)(0*|1*)$' with 1111 MATCH
Found nonmatching strings with length 4: 0101, 1010

Klappt also nicht schlecht. ε ist übrigens der leere String .

Dies ist mein erstes Script in Python überhaupt. Für Anregungen und Verbesserungsvorschläge bin ich mehr als dankbar:
[cc lang="python"]
#!/usr/bin/env python
”’
Find a minimal non-matching string for a given regular expression and an alphabet.
Created on Oct 1, 2011

@author: Skaldrom Y. Sarg
”’
import argparse
import re
import sys

def allstrings(alphabet, length):
“”"Find the list of all strings of ‘alphabet’ of length ‘length’”"”

if length == 0:
return [""]
c = []
for i in range(length): # @UnusedVariable
c = [[x] + y for x in alphabet for y in c or [[]]]

return c

if __name__ == ‘__main__’:
scriptHelp= “msfr: Find a minimal non-matching string for a given regular expression and an alphabet.\n\
\n\
Example: python3 msfr.py ‘(0*|1*)(0*|1*)(0*|1*)’ 0 1″

parser = argparse.ArgumentParser(description=scriptHelp, epilog=’Written by Michael Schneider.’)
parser.add_argument(‘-v, –verbose’, dest=’verbose’, action=’store_true’, default=False, help=’output more verbose’)
parser.add_argument(‘-m, –maxlength’, dest=’maxlength’, default=10, help=’max number of symbols to test (default: 10)’)
parser.add_argument(‘regexp’, type=str, nargs=1, help=’the regular expression’)
parser.add_argument(‘alphabet’, metavar=’S', type=str, nargs=’+', help=’a symbol of the alphabet’)
args = parser.parse_args()

# Start
if(args.verbose):
print(‘Σ: {‘ + “, “.join(args.alphabet)+’}')

foundNonMatch = []
for wordlength in range(0, args.maxlength):
for string in allstrings(args.alphabet, wordlength):
testString = “”.join(string)
testRegexp = args.regexp[0]
if args.verbose:
print(” Testing: ‘^” + testRegexp + “$’ with ” + (testString if len(testString) != 0 else ‘ε’), end=”")
try:
result = re.match(‘^’ + testRegexp + ‘$’, testString)
except re.error as exc:
if args.verbose:
print(“\n”)
print(“ERROR – Invalid regexp: ” + str(exc))
sys.exit(0)

if(result != None):
if args.verbose:
print(” MATCH”)
else:
foundNonMatch.append(testString)
if args.verbose:
print(” NOMATCH”)
if(foundNonMatch):
break
if not foundNonMatch:
print(“No nonmatching strings found until length ” + args.maxlength + “.”)
else:
foundStingsLength = str(len(foundNonMatch[0]))
foundStrings = “, “.join(foundNonMatch) if len(foundNonMatch[0]) > 0 else ‘ε’
print(“Found nonmatching string” + (“s” if len(foundNonMatch) else “”) + ” with length ” + foundStingsLength +”: ” +foundStrings)
[/cc]

Von Haus aus bringt OSX keine Möglichkeit mehr mit, dynamische Signaturen zu erstellen. Entweder, weil es so gedacht war, weil diese Funktion in die Cloud ausgelagert wurde oder wegen eines Bugs. Ich habe so ziemlich alles durchprobiert, was dieser Artikel über fortunes und andere Websites beschrieben haben, doch leider läuft es nicht – oder nicht mehr – so.

Erkenntnisse:

• AppleScripts möchten nicht einfach so mit Tastaturkürzeln versehen werden.
• Das AppleScript Utility gibt es nicht mehr. Um AppleScripts zu aktivieren muss der AppleScript-Editor geöffnet werden und das Skriptmenü in den Einstellungen aktiviert werden (siehe Abbildung).

Skript-Menü im neuen AppleScript-Editor

Will man doch mittels fortune dynamische Signaturen erzeugen, muss man wie Folgt vorgehen:

1. Zuerst braucht man fortune. Dies kann man sich beispielsweise per MacPorts beschaffen. Damit MacPorts läuft, muss XCode vom AppStore installiert werden.
2. Dann sollte man sich eine Zitatsammlung bereit legen, wie im Blogeintrag zu dynamischen Signaturen beschrieben.
3. Dann muss man den Automator starten und einen neuen Service erstellen.
4. Grundeinstellung: “Dienst empfängt keine Eingabe in Mail.app“
5. Als Aktion AppleScript ausführen suchen und einfügen.
6. Das AppleScript:
   [cc lang="AppleScript"]
   on run {input, parameters}

   tell application “Mail”
   activate
   make new outgoing message with properties ¬
   {content:do shell script “/Users/linux/Documents/sigs/psignature-mac”, visible:true}
   end tell
   return input
   end run
   [/cc]
   Natürlich muss der Pfad angepasst werden. psignature-mac ist ein Script mit folgendem Inhalt:
   [cc lang="bash"]
   #! /bin/bash
   echo ” Viele Grüsse”
   echo ” Skaldrom”
   echo “-=-=-=-=-=-=-=-=-”
   /opt/local/bin/fortune `dirname “$0″`/quotes/shorties
   [/cc]
   Dann alles speichern und einen Kaffee trinken oder Kekse backen gehen.

7. Um den Tastaturkürzel festzulegen, muss die Systemeinstellungen geöffnet werden. Dort auf Tastatur → Tastaturkurzbefehle gehen. Der Dienst sollte irgendwo erscheinen und ein Klick auf den leeren Platz rechts davon ermöglicht es, einen Tastaturkurzbefehl einzugeben.
   
8. Mail öffnen, Tastaturkurzbefehl (ja, ich mag dieses Wort) drücken und sich freuen.

Es gibt auch eine Lösung für existierende Mails:
[cc lang="AppleScript"]
on run {input, parameters}

tell application “Mail”
activate
get do shell script “/Users/linux/Documents/sigs/psignature-mac”
copy return & the result ¬
to theFortune

tell application “System Events”
tell process “Mail”
keystroke theFortune
end tell
end tell
end tell
return input
end run
[/cc]

• doxygen
• phuml
• php-lint
• PHP Callgraph

Doxygen statt phpDocumentor

Ich hab grössten Respekt vor dem phpDocumentor Projekt, aber Doxygen hat ein paar Vorteile:

• Es kann mit nicht-UTF-8-Dateien umgehen.
• Es ist schneller.
• Es kommt mit anonymen Funktionen klar.

Leider ist es nicht zu 100% kompatibel zu phpDocumentor. Es hat Mühe mit Kurzbeschreibungen, Parametern, etc.

Die Inbetriebnahme ist ganz einfach: mittels doxygen -g CONFIGNAME wird eine Standardkonfiguration erstellt, die man am Besten sofort editiert und mindestens folgende Dinge anpasst:

Name des Projekts

PROJECT_NAME = Simple PHP Fixtures System

Ausgabeverzeichnis

OUTPUT_DIRECTORY = statistics/html/doc/api/

Auch private Members anzeigen

EXTRACT_PRIVATE = YES

Verzeichnis des zu dokumentierenden Codes

INPUT = ../code

SVN-Verzeichnisse nicht durchsuchen

EXCLUDE_PATTERNS = */.svn/*

Automatische Kurzbeschreibungen

JAVADOC_AUTOBRIEF = YES

Wird der Dokumentationsvorgang nun mittels doxygen CONFIGNAME gestartet, so geht es unglaublich schnell und man hat eine peppige API-Dokumentation:

Das Ant-Target aus dem letzten Artikel kann folgendermassen umgeschrieben werden:
[cc lang="xml"]





[/cc]

doxygenconf muss natürlich noch in der properties-Datei mit dem Pfad der Configdatei gefüllt werden.

Phuml

phUML erzeugt – nicht ganz standardkonforme – UML-Diagramme aus PHP-Code. Je nach Veranlagung sieht man ziemlich schnell, wenn etwas in der Struktur schief gelaufen ist. Wurde das Phuml-SVN ausgecheckt, kann mit dem Kommando php phuml -r -graphviz -createAssociations true -neato uml.png ein Diagramm erstellt werden. Möchte man lieber ein anderes Format als ng, so kann das in der Datei phuml/src/classes/processor/neato.php, Funktion execute() auf der Zeile mit 'neato -Tpng -o [...] umgestellt werden. Zur Verfügung stehen viele: ps, pdf, svg, gif, … man neato gibt gerne Auskunft.

UML-Diagramm

PHP-Lint

Die Lints haben eine lange Geschichte in der Programmierung, sie sind sozusagen das Werkzeug für statische Code-Analyse. Im Gegensatz zu einigen Anderen bin ich der Meinung, dass php -l ein Syntaxcheck und damit kein Lint ist. Für PHP heisst das Teil PHPLint und ist ebenso kritisch wie die Lints für andere Sprachen. Es macht Gebrauch von PHP-Doc Kommentaren für erweiterte Analyseinformationen. Leider kann PHP-Lint (im Moment) nicht mit Closures umgehen und etwas speziell ist, dass die verwendeten PHP-Module zu Beginn der zu untersuchenden Dateien aufgeführt werden müssen:
[cc lang="php"]
/*.
require_module ‘standard’;
require_module ‘pdo’;
require_module ‘session’;
.*/
[/cc]

Ebenfalls kann man ihm mit expliziten castings wie (string) oder etwas hässlichen Kommentaren /*. string .*/ im Code bei der Arbeit unterstützen.

Die Installation läuft folgendermassen:

1. Download der entsprechenden Version (pure-c für Linux).
2. Entpacken des Tars und eventuell kompilieren.
3. Ein eigenes Verzeichnis erstellen (bspw. /opt/php/phplint
4. Das Verzeichnis modules und die Datei src/phplint in das erstellte Verzeichnis kopieren.
5. phplint starten mittels: /opt/php/phplint/phplint --modules-path /opt/php/phplint/modules/
6. Nun sollten ganz viele Fehler ausgegeben werden.
   [cc]
   …
   /home/skaldrom/svn/syncic/SimplePHPFixturesSystem/trunk/code/SimpleFixtures.php:136: Warning: comparing (mixed) == (mixed): `mixed’ type cannot be compared. Hint: check and convert mixed values to the appropriate type, or consider to use strict comparison operators === or !== if it is the case.
   /home/skaldrom/svn/syncic/SimplePHPFixturesSystem/trunk/code/SimpleFixtures.php:139: notice: ‘continue EXPR’: unadvised programming practice
   /home/skaldrom/svn/syncic/SimplePHPFixturesSystem/trunk/code/SimpleFixtures.php:135: notice: variable `$foreignkey’ assigned but never used
   /home/skaldrom/svn/syncic/SimplePHPFixturesSystem/trunk/code/SimpleFixtures.php:126: notice: variable `$candidateData’ assigned but never used
   /home/skaldrom/svn/syncic/SimplePHPFixturesSystem/trunk/code/SimpleFixtures.php:170: Warning: comparing (mixed) == (string): `mixed’ type cannot be compared. Hint: check and convert mixed values to the appropriate type, or consider to use strict comparison operators === or !== if it is the case.
   /home/skaldrom/svn/syncic/SimplePHPFixturesSystem/trunk/code/SimpleFixtures.php:176: Warning: applying the `[]‘ operator to array of undefined index type
   /home/skaldrom/svn/syncic/SimplePHPFixturesSystem/trunk/code/SimpleFixtures.php:178: ERROR: method `SimpleFixtures::_untangleTree()’: expected return type void, found expression of type array[]string
   /home/skaldrom/svn/syncic/SimplePHPFixturesSystem/trunk/code/SimpleFixtures.php:183: Warning: calling `SimpleFixtures::_untangleTree()’ declared in line 160, argument no. 1: found type `mixed’, required type `string’
   /home/skaldrom/svn/syncic/SimplePHPFixturesSystem/trunk/code/SimpleFixtures.php:188: Warning: applying the `[]‘ operator to array of undefined index type
   …
   [/cc]

Damit phplint auch in Jenkins genutzt werden kann, habe ich einen kleinen Wrapper geschrieben, der die Ausgabe in JSLint-XML umwandelt. Damit kann diese Ausgabe komfortabel beim Violations-Modul eingebaut werden. Die PHP-Datei muss im selben Verzeichnis wie phplint platziert werden und geht davon aus, dass modules ein Unterverzeichnis ist. Download hier: phplint.php.

PHPLint in Jenkins

Ein grosses Problem gibt es in Netbeans… Wird der PHP-Code neu formatiert, werden bei den Kommentaren um die Module herum Leerschläge platziert und phplint erkennt sie nimmer. Sehr nervig, echt…

PHP Call Graph

php CallGraph ist ein wunderbares Stück Software, dass einige bestehende Libraries clever vereint. Es produziert Aufrufgraphen einer bestehenden Software, die ziemlich effizient mit dem intuitiven Plan des Entwicklers verglichen werden können. Schöne Beispiele gibt es auf der Website.

phpCallGraph verlässt sich unter Anderem auf phpDoc-Kommentare. Die sollten also entweder gar nicht oder einigermassen gescheit ausgefüllt werden. Sollte es trotzdem ein Problem geben, so kann zum Debuggen die Zeile 517 und 518 in der Datei lib/instantsvc/components/CodeAnalyzer/src/code_analyzer.php entkommentiert werden:
[cc lang="php"]
echo ‘$filename = ‘, var_export($filename, true), “;\n”;
echo ‘$result = ‘, var_export($result, true), “;\n”;
[/cc]

Ich habe einen Patch eingereicht, der einige Warnings entfernt und eine “ignore” Option hinzufügt, der alsbald angewendet wird.

Da war ich zu blöd dafür

Für php-ast und php-sat war ich leider zu blöd. Ich hatte weder Nerven noch Zeit für die Build-Prozedur und die Projekte scheinen auch seit längerem still zu liegen. Die Ideen wären aber grundsätzlich interessant.

Diese Bewunderung sollte in Zahlen gefasst werden: mit Statistiken, Diagrammen, Balken und Graphen. Dies dient zur Vorbereitung der “Continuous Integration” mit Jenkins/Hudson, die in dieser Serie behandelt wird. Als Quellen haben vor allem jenkins-php und ein äusserst Lesbarer Artikel im Entwickler Magazin 01/11 gedient.

Hier wird nun gezeigt, wie mit einem Befehl:

• Die Unittests durchführt.
• Qualitative Softwaremetriken mit PHP Depend misst: Hierarchietiefe, Komplexität, …
• Unschöne Teile mit PHPMD identifiziert.
• Copy-Paste-Verbrecher aufspührt mit phpcpd.
• Den Coding-Style prüft mit dem PHP Code Sniffer.
• Quantitative Softwaremetriken mit phploc misst.
• Die PHPDoc-Doku erstellt.
• Die Resultate mit dem PHP Code Browser schön darstellt.

PEAR Tools installieren

PEAR stellt viele Hilfsprogramme zur Analyse zur Verfügung. Darum muss zuerst pear und danach diese Tools installiert werden. Am Besten als Root, wenn man nicht ein riesen Chaos verursachen möchte:
[cc lang="bash"]
sudo pear upgrade PEAR
sudo pear channel-discover pear.pdepend.org
sudo pear channel-discover pear.phpmd.org
sudo pear channel-discover pear.phpunit.de
sudo pear channel-discover components.ez.no
sudo pear channel-discover pear.symfony-project.com

sudo pear install Text_Highlighter-0.7.1
sudo pear install pdepend/PHP_Depend
sudo pear install phpmd/PHP_PMD
sudo pear install phpunit/phpcpd
sudo pear install phpunit/phploc
sudo pear install PHPDocumentor
sudo pear install PHP_CodeSniffer
sudo pear install –alldeps phpunit/PHP_CodeBrowser
sudo pear install –alldeps phpunit/PHPUnit
[/cc]

Ant build Files

Um den Build zu steuern, eignet sich Ant sehr gut. Zwar ist es XML (Anwender sollen kein XML schreiben müssen!), stellt aber ein paar vernünftige Funktionen bereit. Für einen Build braucht es eine Properties- und eine XML-Datei, die am Besten in ein eigenes build Verzeichnis verfrachtet werden. In der Propertiesdatei können Variablen gesetzt und eventuell auf verschiedene Umgebungen reagiert werden. Bei mir heisst sie build.properties und sieht ziemlich einfach aus:
[cc lang="bash"]
# Source directory
source=${basedir}/../htdocs/code
# Target directory
builddir=${basedir}/statistics
# Where are the Unittests
unittests=${basedir}/tests
testsuite=suite.php
# 10: Highest priority, 1: Lowest
niceness=1
# Set to a random String if you have no external libraries. PHPCPD accepts only ONE directory
extlib=inc/external
phpdocextlib=*${extlib}/*
extlibs=${extlib},\\.svn
# Files to consider
suffixes=php
# Ruleset for Code Sniffer
csruleset=${basedir}/conf/syncic
[/cc]

Hier sieht man auch schon eines der Hauptprobleme: Die Tools verwenden unterschiedliche Angaben um Verzeichnisse auszuschliessen: Pfade, RegExps, durch Komma getrennt, … Ziemlich mühsam.

Die Build-Datei build.xml ist etwas lange, aber gut verständlich. Zuerst werden die abstrakten Ziele eingerichtet und dann gibt es für jedes Tool ein Target.

[cc lang="xml"]

[/cc]

Ist alles richtig eingerichtet, kann der Build mit dem Kommando ant gestartet werden.

Hinweis: Das Coverage-XML und das Coverage-HTML müssen im gleichen Verzeichnis sein. Wenn der Clover-Report nicht funktioniert und ein 404 not found gibt, liegt es wahrscheinlich daran…

Code Sniffer einrichten

Der Stil des Codes (Einrücken, Benamsung, …) ist sehr persönlich. Sehrwahrscheinlich werden viele Warnungen gezeigt, mit denen man gar nicht einverstanden ist. Das ist aber kein Problem, denn der Codesniffer erlaubt es, eigene Codingstandards zu definieren. mit der neuen Version 1.3 (die mittels sudo pear install PHP_CodeSniffer-1.3.0RC2 installiert werden kann) geht das ziemlich einfach. Dafür brauch es in einem Grundverzeichnis eine ruleset.xml Datei und in einem Unterverzeichnis Sniff die eigenen Regeln, in PHP auscodiert. In ruleset.xml kann man sich frei an nestehenden Regeln bedienen. Meines sieht folgendermassen aus:
[cc lang="xml"]

[/cc]

In dieser Datei übernehme ich vor allem den PEAR-Standard, konfiguriere etwas herum und mische ein paar allgemeine Regeln hinzu. Vorallem die Indentation mit Spaces wollte ich anpassen. Im Sniffs Verzeichnis habe ich meine eigenen Regeln. Beispielsweise ControlStructures/ControlSignatureSniff.php (angepasst vom PEAR Coding Standard:
[cc lang="php"]
/**
* Verifies that control statements conform to their coding standards.
*/

if (class_exists(‘PHP_CodeSniffer_Standards_AbstractPatternSniff’, true) === false) {
throw new PHP_CodeSniffer_Exception(‘Class PHP_CodeSniffer_Standards_AbstractPatternSniff not found’);
}

/**
* Verifies that control statements conform to their coding standards.
*/
class syncic_Sniffs_ControlStructures_ControlSignatureSniff extends PHP_CodeSniffer_Standards_AbstractPatternSniff {
/**
* Constructs a PEAR_Sniffs_ControlStructures_ControlSignatureSniff.
*/
public function __construct() {
parent::__construct(true);

}//end __construct()

/**
* Returns the patterns that this test wishes to verify.
*
* @return array(string)
*/
protected function getPatterns() {
return array(
‘do {EOL…} while (…);EOL’,
‘while(…) {EOL’,
‘for(…) {EOL’,
‘if(…) {EOL’,
‘foreach(…) {EOL’,
‘} else if(…) {EOL’,
‘} elseif(…) {EOL’,
‘} else {EOL’,
‘do {EOL’,
);

}//end getPatterns()
}//end class
?>
[/cc]

Was gewinnen wir damit?

Nach einem ant haben wir zum Einen ganz viele XML-Dateien. In einem späteren Beitrag werde ich zeigen, wie diese in ein “Continuous Integration” System integriert werden können. Für Menscen Lesbar haben wir Folgendes:
Dokumentation unter statistics/html/doc/api/:

PHPDoc Beispiel

Eine Liste aller Style-Verstösse und Chaosattacken unter statistics/html/doc/codebrowser/:

Codebrowser Output

Ein Coverage-Report der Unittests unter statistics/html/unittests/coverage/:

Coverage Report

Zwei nette Diagramme von PHP-Depend (eine Abstraction Instability Chart und eine Overview Pyramid) unter statistics/html/jdepend:

Fazit

In einem nächsten Beitrag werde ich noch weitere Tools vorstellen und dann soll das alles ganz automatisch bei jeder Änderung geschehen… Stay tuned…

]]>

Sehr interessant ist der Verlauf des Wettbewerbs des Linux-Magazins. Alles ging gut bis zum Abgabetermin am 12. September 2010. Ab dann war der Wurm drin: Die versprochenen Bestätigungsmails an die Teilnehmer sind nie eingetroffen und der Organisator ist “abgetaucht”. Die Wettbewerbsteilnehmer haben viel Geduld gezeigt, das Wiki regelmässig von Spam gereinigt und abgewartet.

Nachdem die ersten unangenehmen Fragen aufgetaucht sind, hat sich die Organisation gemeldet und verkündet, dass ein Bericht in der Novemberausgabe des Magazins erscheinen wird. Das ist er dann auch, aber mehr ist bis jetzt nicht passiert. Der Unmut wird immer grösser, vor allem nachdem eine Teilnehmerliste veröffentlicht wurde, auf der einige Bots fehlen. Leider gibt es weiterhin nur spärlich Neuigkeiten. Eine Community ist ein Dialog: Wird er vom Organisator nicht geführt, führt ihn die Community alleine.

Wir sind hier organisatorisch mit einem ähnlichen Problem konfrontiert: Programme in vielen Programmiersprachen werden abgegeben und müssen von uns bewertet werden. Auch ein kleiner Mehraufwand pro einzelner Lösung summiert sich schlussendlich zu sehr viel Zeit. Das Einzige, das hilft, ist Denken im Voraus. Klare Richtlinien und Regeln, sonst wird der Aufwand unüberschaubar riesig. Es gibt Beispiele von erfolgreich durchgeführten Wettbewerben: Avaloqix wurde life durchgeführt mit Anwesenden, der Google AI-Contest oder die alten Codezone (Microsoft) Wettbewerbe haben ebenfalls gezeigt, wie es gehen könnte. Ich möchte den Organisatoren vom Linux-Magazin nicht in die Suppe spucken, und wenn sie die Durchführung noch hinkriegen, haben sie meinen grössten Respekt und viel gearbeitet, aber irgendwie war es ein Schnellschuss.

So ganz per Zufall habe ich noch eine nette Sache entdeckt: Das Freie Magazin führt ebenfalls einen sehr interessanten Wettbewerb durch. Tip: Das LIESMICH im Download lesen ….

Doch zu früh gefreut, jetzt kommt das: Die Google AI-Challenge. Man kann nicht mal was gewinnen, aber das Spiel ist unglaublich genial: Es geht darum, Planeten zu erobern:

Es gibt jetzt schon Starter-Packages für verschiedene Sprachen und das System ist ziemlich offen (für unsere Shell-Krieger ). Ab dem 10.09.2010 kann man sich dann offiziell eintragen und losranken.

Nun, ich habe eine neue Version des Clients unten hingehäng: Stabiler, so dass er auch eine ganze Nacht über viele Stunden und Verbindungsprobleme hinweg weiterspielt.

Oh nein. Frisch erkältet wollte ich mich auf die Arbeiten stürzen, die eigentlich schon letztes Jahr hätten erledigt sein müssen, und nun das: Das Linux-Magazin veranstaltet einen Wettbewerb für Programmierer! Die Details sind in der Ausgabe 09/10 (auch online) beschrieben und es gibt eine Wettbewerbs-Seite dazu.

Grundsätzlich geht es darum, dass zwei Programme gegeneinander würfeln. Wer zuerst 50 Punkte oder mehr erreicht, hat gewonnen. Ist man am Zuge, so kann man entweder Würfeln oder “Save”n. Bei einem Wurf werden die Augen zu der eigenen Punktzahl hinzugezählt, ausser man würfelt eine 6, dann werden alle Punkte seit dem letzten Save wieder abgezogen. Bei einem Save werden die Punkte gespeichert und der Gegner ist am Zuge.

Gespielt wird richtig Harte-Männer-mässig über einen TCP-Port mit einem definierten, menschenlesbaren Protokoll.

Die Programmiersprache kann frei gewählt werden, insofern sie in Ubuntu 10.04 vorhanden ist und mit einem Makefile gebuildet und gestartet werden kann. Ich hab mich mal wieder für PHP (Kommandozeile) entschieden weil das Problem, hmm, überhaupt nicht zeitkritisch ist (nein, auch diesmal kein Monte-Carlo) und auch sonst, hmm, und überhaupt nicht weil ich zu faul war ein Makefile für Java zu schreiben oder meine C-Kenntnisse aufzufrischen .

Als Erstes habe ich einen Simulator für einen Benchmark implementiert. Als Messgrösse habe ich die Anzahl “Transaktionen” gewählt, also wie oft mein Programm dran war mit Würfeln bis die 50 erreicht wurden. Dabei habe ich ein paar interessante Erkenntnisse gewonnen: So sind zum Beispiel die Resultate sehr unterschiedlich wenn zufällig mit Wahrscheinlichkeit 1/4 oder wenn jedes 4. mal gesaved wird. Auch die optimale Wahrscheinlichkeit habe ich so nicht erwartet wie sie gemessen wurde.

Um meine Arbeit etwas zu teilen und um den Einstieg zu erleichtern, publiziere ich hier meine Spielerumgebung. Der geneigte Wettbewerbsteilnehme müsste nun nur noch:

• Den Spielernamen ändern (Konstante NAME),
• Die Methode play mit Intelligenz füllen.

Zuerst das Makefile:
[cc lang="Make"]
PHP = /usr/bin/php

build:
echo “PHP muss nit gebuildet werden .”
game: wettbewerb.php
$(PHP) ./wettbewerb.php
[/cc]

Und hier der Spieler wettbewerb.php, bereit getuned zu werden:
[cc lang="php"]
/**
* Wettbewerbsgeruest von Skaldrom Y. Sarg (http://blog.oncode.info)
*/

define(“NAME”,”test.spieler”); // UNBEDINGT AENDERN!!!! Kleinbuchstaben, keine Sonderzeichen
define(“LOGFILE”,”dice.log”); // Schreibt keines wenn leer (fuer den Wettbewerb)
define(“SERVER”, “wettbewerb.linux-magazin.de”);
define(“PORT”, 3333);

class wettbewerb {

/**
* Dies ist die Spielfunktion.
*
* Macht was cleveres, aber stehlt mir nicht die Preise!
*
*
* @param $numThrowsThisTransaction int Anzahl Würfe seit letzter 6 oder letztem Save
* @param $currentTransactionPoints int Punkte seit letzter 6 oder letztem Save
* @param $pointsAtLastSave int Punkte bei letztem Save
* @param $transactions int Anzahl gemachter Züge
* @param $numSaves int Anzahl Saves
* @param $enemyPoints int Punkte des Gegners
* @param $rollsThisTransaction Array Würfe in diesem Durchgang
*
* @return String “roll” für einen Wurf, “save” um zu speichern und abzugeben.
*/

function play($numThrowsThisTransaction, $currentTransactionPoints, $pointsAtLastSave, $transactions, $numSaves, $enemyPoints, $rollsThisTransaction) {
$this->log(“[PLAY-RESULT]: ROLL.”);
return “roll”;
}

function log($message) {
if(LOGFILE) {
error_log(date(“r”).”: “.$message.”\n”, 3, LOGFILE);
}
}

function secureFGetS() {
$response=”";
if(!$this->socket) {
do {
$this->connect();
} while(!$this->socket);
}
$response=fgets($this->socket);
$info = stream_get_meta_data($this->socket);
if ($info['timed_out']) {
$this->log(“Got a Socket Timeout! (unread:”.$info['unread_bytes'].”)”);
fclose($this->socket);
$this->socket=0;
$response=”";
sleep(5);
}
return $response;

}

function connect() {
// Kontaktaufnahme
$this->socket=0;
while(!$this->socket) {
$this->log(“CONNECTING”);
$this->socket = @fsockopen(SERVER , PORT, $errno , $errstr , 180);
if(!$this->socket) {
$this->log(“Verbindungsversuch fehlgeschlagen: ($errno) $errstr.”);
sleep(5);
}
}
if(function_exists(“stream_set_timeout”)) {
$this->log(“Set Socket Timeout.”);
stream_set_timeout($this->socket, 120); //two Mins
}
// Antwort des Servers
$this->log(“CONNECTED”);
}

function playARound() {
$this->log(“—————– NEW GAME “.SERVER .”:”.PORT.” —————–”);

do {
$this->connect();
} while(!$this->socket);
do {
$response=$this->secureFGetS();
} while (!$response);
$resInfo=split(” “, $response);
$serverCommand=strtoupper(trim($resInfo[0]));
$this->log(“[SERVER]: “.trim($response).” (“.$serverCommand.”)”);
switch($serverCommand) {
case “HELO”: break; // Alles OK
case “DENY”: fclose($this->socket);
return;
break; // Dann halt nicht
default: fclose($this->socket);
$this->log(“[CLIENT]: Exit on Hello because we do not understand [$serverCommand].”);
exit(); // DAS verstehen wir nicht!
}

// Authentifizierung
$message=”AUTH “.strtolower(NAME);
$this->log(“[CLIENT]: “.$message);
fputs($this->socket, $message.”\n”);

// Los gehts!
$currentPlayer=1; // Wer ist am Zug? 0 == wir, 1 == der Andere
$numThrowsThisTransaction=0;
$currentTransactionPoints=0;
$pointsAtLastSave=0;
$transactions=1;
$numSaves=0;
$enemyPoints=0;
$rollsThisTransaction=array();
do {
$response=”";
$response=$this->secureFGetS();
if(!$response) {
$this->log(“INGAME TIMEOUT: Forgetting this game.”);
return;
}
$this->log(“[SERVER]: “.trim($response));
$resInfo=split(” “, $response);
$serverCommand=strtoupper(trim($resInfo[0]));
switch($serverCommand) {
case “THRW”: // Ein Wurf
if($currentPlayer==0) { // Wir sind dran
if($resInfo[1]==6) { // Ooops, eine 6 gewürfelt
$currentPlayer=1; // Der Andere ist dran
$currentTransactionPoints=0;
$numThrowsThisTransaction=0;
$transactions++;
$rollsThisTransaction=array();
} else {
$numThrowsThisTransaction++;
$currentTransactionPoints+=$resInfo[1];
$rollsThisTransaction[]=$resInfo[1];
}
}
break;
case “DENY”: break; // Dann halt nicht
case “TURN”:
$currentPlayer=0; // Wir sind dran!
$enemyPoints=$resInfo[2];
$pointsCurrentOurs=$resInfo[1];
$currentTransactionPoints=$pointsCurrentOurs-$pointsAtLastSave;
// Here we play!
$ret=$this->play($numThrowsThisTransaction, $currentTransactionPoints, $pointsAtLastSave, $transactions, $numSaves, $enemyPoints, $rollsThisTransaction);
if(strtolower($ret==”roll”)) { // Rollin’ Baby
$this->log(“[CLIENT]: ROLL”);
fputs($this->socket, “ROLL\n”);
} else { // Save
$this->log(“[CLIENT]: SAVE”);
fputs($this->socket, “SAVE\n”);
$transactions++;
$rollsThisTransaction=array();
$numThrowsThisTransaction=0;
$numSaves++;
$pointsAtLastSave=$pointsCurrentOurs;
$currentTransactionPoints=0;
$currentPlayer=1;
}
break;
case “DEF”:
case “WIN”: break;
default: fclose($this->socket);
$this->log(“[CLIENT]: Exit because we do not understand [$serverCommand].”);
exit(); // DAS verstehen wir nicht!
}
} while (!in_array($serverCommand, array(“DENY”, “DEF”, “WIN”)));
// Feddich Lustig
fclose($this->socket);
}

}

$w=new wettbewerb();
for($i=0;$i<1000;$i++) {
echo “*** $i ***\n”;
$w->playARound();
}
?>
[/cc]

• Jemand muss die Aufgabe erledigen. Zum Glück ist das ein PAL (Problem anderer Leute) .
• “In einem Monat” und “In einem Jahr” kann nicht trivial in Sekunden umgerechnet werden. Irgendein Soziopath hat mal bestimmt, dass nicht alle Monate und Jahre die gleiche Anzahl Tage haben. Ganz zu schweigen von Schaltsekunden und Sommer-/Winterzeit.
• Aus hier zu verschweigenden Gründen habe ich weder Lust noch Zeit ein GUI mit 7 Textfeldern für Jahre, Monate, Wochen, Tage, Stunden, Minuten und Sekunden aufzubauen.

Ich habe mich für ein simples Eingabefeld entschieden, in denen das Erledigungsintervall in der Form “Zahl Zeitbezeichner Zahl Zeitbezeichner …” eingegeben werden kann. In obigem Beispiel wäre das: “2m 1w 4s“.

Leider ist die Aufgabe ein Bisschen zu klein um einen richtigen Parser hochzufahren , und so habe ich die kleineren Kanonen hervorgeholt. Meine Idee is die Folgende: Dieses Intervall wird in einen String übersetzt, der direkt an strtotime übergeben werden kann. Soll sich diese Funktion doch um die Hässlichkeiten der Zeit kümmern.

Mein Ansatz ist zweistufig: Erst wird geparst und ein Array aus den Tokens erzeugt. Im Idealfall also immer abwechselnd “number” und “alpha”. Im zweiten Schritt wird dann der String daraus geformt. Hier der Code für alle armen Seelen, die vielleicht mal auf dasselbe exotische Problem treffen sollten. Mir ist bewusst, dass ich auch mit RegExpen hätte arbeiten können, aber die sind eh nur für Weicheier :

[cc lang="php"]
/**
* Parses a string with an interval into a string that is understood by strtotime.
*
* Example: “3w 2d 4h 2s” means 3 Weeks, 2 days, 4 hours
*/
function timeIntervalToStrtotime($timeInterval) {
$tokens=array();
$currentTokenType=”";
$currentToken=”";

// Poor man’s scanner
for($i=0; $i

// Ignore whitespaces
if(ctype_space($timeInterval[$i])) {
continue;
}

// Numbers or names
$thisTokenType=ctype_digit($timeInterval[$i])?”numeric”:”alpha”;

if($currentTokenType == $thisTokenType) {
$currentToken.=$timeInterval[$i];
} // Else
if($currentTokenType != $thisTokenType) { // New Tokentype
if($currentTokenType!=”") { // Not first token
// Save old token
$tokens[]= array(“type” => $currentTokenType, “token” => $currentToken);
} else { // First token must be numeric
if($thisTokenType!=”numeric”) {
return “”;
}
}
$currentTokenType=$thisTokenType;
$currentToken=$timeInterval[$i];
}
}
// Save last Token
if($currentTokenType!=”") {
$tokens[]= array(“type” => $currentTokenType, “token” => $currentToken);
}

// Poor man’s parser

// There has to be an even number of tokens
if(count($tokens) % 2 != 0) {
return “”;
}

$ret=array();
for($i=0; $i switch(strtolower($tokens[$i+1]["token"])) {
case “a”:
case “y”:
case “yr”:
case “year”:
case “years”: $ret[]=”+”.$tokens[$i]["token"].” years”; break;
case “m”:
case “mon”:
case “month”:
case “months”: $ret[]=”+”.$tokens[$i]["token"].” months”; break;
case “w”:
case “week”:
case “weeks”: $ret[]=”+”.$tokens[$i]["token"].” weeks”; break;
case “d”:
case “day”:
case “days”: $ret[]=”+”.$tokens[$i]["token"].” days”; break;
case “h”:
case “hr”:
case “hour”:
case “hours”: $ret[]=”+”.$tokens[$i]["token"].” hours”; break;
case “m”:
case “min”:
case “mins”:
case “minute”:
case “minutes”: $ret[]=”+”.$tokens[$i]["token"].” minutes”; break;
case “s”:
case “sec”:
case “secs”:
case “second”:
case “seconds”: $ret[]=”+”.$tokens[$i]["token"].” seconds”; break;
default: return “”;
}
}
return join(” “, $ret);
}

$tests=array(“1s”, “1″, ” 1y 2d 3 mins 4sec”, ” 15 yr “, “a2 3mon”);
foreach($tests as $test) {
echo “TEST:[$test]: “.timeIntervalToStrtotime($test).”\n”;
}
[/cc]

SQL ist eine geniale Erfindung. Zwar wird es im Moment arg von den schmächtigen noSQL bedrängt, aber es wird wie triumphieren *star-wars-musik-on*, denn die Anderen werden untergehen wie die noAngels, es wird gewinnen wie die Maden über die noMaden, häufiger verwendet werden, so wie es das Ah gegenüber noAh wird und edler sein, wie der Orden gegenüber noRden! Ich bin heute noch auf der Suche nach der vernünftigen Frage, die nicht in ein einziges SQL-Statement verpackt werden kann.*star-wars-musik-off*

Beispiel-Schema

Doch zurück zum Problem: Es seien Entitäten gegeben, die m:n Beziehungen zu “lookup-Werten” haben. Ein bestehender Wert in einem Set also, das sich selten ändert wie beispielsweise Kategorien, Zustände, Farben, Ländercodes, Geschlechter oder so etwas. Ein weiterer Use Case wäre ein Import, bei dem die Datensätze schon erstellt wurden und nun nur noch die Verbindungen fehlen.

Hier ein Beispiel:
Personen beinhalten, ja ratet mal, Personen.Hier vereinfacht nur mit Namen und Vornamen.
Personentypen bezeichnen die Art der Person. Beispielsweise Lernender, Lehrperson, Verwaltungsangestellter oder auch Schulleiter.

Jede Person kann mehreren Personentypen entsprechen. Diagnose: klassisches m:n mit Verbindungstabelle (personen_personentypen).

Die Inhalte der Tabellen gestalten sich folgendermassen:

Personen

+----+---------------+-----------+
| id | name          | vorname   |
+----+---------------+-----------+
|  1 | Schinkler     | Sebastian |
|  2 | Moser         | Hanspeter |
|  3 | Gublinsbacher | Anneli    |
|  4 | Iltis         | Mahara    |
+----+---------------+-----------+

Personentypen

+----+-------------------------+
| id | personentyp             |
+----+-------------------------+
|  1 | Lernender               |
|  2 | Lehrperson              |
|  3 | Verwaltungsangestellter |
|  4 | Schulleiter             |
+----+-------------------------+

Insert kombiniert mit Select

Der alte Ablauf war folgendermassen:

1. Lese ID von Personen.
2. Lese ID von Personentypen.
3. Füge einen neuen Verbindungsdatensatz in personen_personentypen ein.

Doch es geht viel einfacher! Die Werte, die in personen_personentypen eingefügt werden sollen, können direkt im Statement selektiert werden. Grundsätzlich fügt man also das Resultat einer Abfrage ein:

[cc lang="sql"]
INSERT INTO personen_personentypen
SELECT p.id, pt.id FROM personen p, personentypen pt
WHERE p.name=’Moser’ AND p.vorname=’Hanspeter’ AND pt.personentyp=’Lehrperson’
[/cc]

Wirklich effizient wird es, wenn man gerade mehrere Lookupwerte verbindet:
[cc lang="sql"]
INSERT INTO personen_personentypen
SELECT p.id, pt.id FROM personen p, personentypen pt
WHERE p.name=’Gublinsbacher’ AND p.vorname=’Anneli’ AND pt.personentyp IN(‘Verwaltungsangestellter’, ‘Schulleiter’)
[/cc]

Jaaa, mit so einfachen Dingen kann man mich glücklich und zufrieden machen…