Musings Of An Idiot

NCrunch

Mon, 06 Feb 2012 13:15:36 GMT

A few months ago I was introduced by a colleague to a fantastic Visual Studio extension called NCrunch, and in a single stroke it has managed to almost completely change the way that I write, develop and maintain code (for the better).

NCrunch is an automatic continuous testing tool that, in the background, runs your unit tests against your code while you are developing. It adds a column of status indicators to your editor, which shows you three things:

Lines of code that are not covered by any unit tests
Lines of code that are covered by unit tests where all unit tests pass
Lines of code that are covered by unit tests where at least one test is failing

So, if I make a change to my code while I'm implementing a new business requirement or refactoring I get almost immediate feedback that my code has or hasn't adversely affected my other code paths (assuming that is that I've got appropriate unit test cases written for my code).

Which is the other great thing about NCrunch from my perspective - over time, the presence of a black dot to the left of your code that indicates that you've not got any unit test coverage for a particular code path starts to grate. In fact, whenever I've had to write code recently in projects that have no code coverage I've almost felt dirty - that little black dot keeps nagging me to drop what I'm doing and get some proper unit test coverage in place.

The ultimate accolade I can give NCrunch is that when I built a new development environment a few weeks ago, firing up Visual Studio without NCrunch (and ReSharper for that matter) felt unnatural and incomplete - a lot of extensions are 'nice to have', but this is now on my immediate install list.

NCrunch is still in beta at the moment and undergoing active development so there are sometimes some rough edges, but even given that it has been one of the most useful tools I've ever used.

Calling MVC Areas From WebForm Pages

Fri, 05 Aug 2011 14:30:22 GMT

I'm currently working on a project that involves moving a large classic ASP.NET WebForms application to ASP.NET MVC3; rather than completing re-implementing the system as MVC3 in one large hit, we're taking a hybrid approach so that existing WebForms content can run alongside the new MVC3 code.

As part of this work, we realised we would need to be able to render content from ASP.NET MVC Areas from within WebForms pages, otherwise there would be a huge duplication of work involved in producing UserControls (or ServerControls) that duplicated the new functionality we are already writing as Areas. So, we started hunting around for a way to achieve this.

After hunting around in MSDN and on StackOverflow, it turns out the solution is moderately easy; the first step is to create a dummy Controller:

public class WebFormController : Controller
{
}

Seriously, that's all there is to it. Next, create a partial view that does nothing but render an Area:

@Html.Action("Index", "Home", new { Area = "HelloWorld" })

Again, stupidly simple. The magic happens here though:

public class WebFormMvcUtil
{
    public static string RenderPartial(string partialName, object model)
    {
        var httpContextWrapper = new HttpContextWrapper(HttpContext.Current);

        var routeData = new RouteData();
        routeData.Values.Add("controller", "WebFormController");

        var controllerContext = new ControllerContext(new RequestContext(httpContextWrapper, routeData),
                                                      new WebFormController());

        IView view = ViewEngines.Engines.FindPartialView(controllerContext, partialName).View;

        ViewContext viewContext;
        var stringBuilder = new StringBuilder();
        using (var stringWriter = new StringWriter(stringBuilder))
        {
            viewContext = new ViewContext(controllerContext, view, new ViewDataDictionary {Model = model}, new TempDataDictionary(), stringWriter);
            view.Render(viewContext, viewContext.Writer);
        }

        return stringBuilder.ToString();
    }
}

With this in place I can now place a

<%= WebFormMvcUtil.RenderPartial("_Area", null) %>

directive in my WebForms page. So now, I have a mechanism to invoke a PartialView (and therefore, by extension, an Area) from our old codebase. Phew, crisis averted!

Home Farm Festival 2011

Fri, 15 Apr 2011 14:15:40 GMT

I’m chuffed to say that Cryin’ Out Loud will be playing at the 6th Home Farm Festival in Chilthorne Domer on Saturday 11th June 2011; the full line up for the day is:

The Helm
No Closure
Hundred Days
My Chloroform
Cryin’ Out Loud
Brought Into Being
Bleedin Hartz
Disciples
Shynah
The Little Unsaid
Nick Tatham

Go get your tickets people!

Wuthering Heights

Wed, 13 Apr 2011 11:28:37 GMT

A live version of Kate Bush’s classic Wuthering Heights by the idiot bunch of loons that I sing with on a regular basis; this was recorded at The Royal Oak, Ilminster on June 4th 2010 after much beer had been consumed, so all duff notes and mistakes are – er – deliberate!

Autoloading Powershell Modules

Wed, 13 Apr 2011 09:18:55 GMT

In a previous post I showed a simple module to check the validity of XML documents from a Powershell command line. Over the past few months I’ve found this little function to be incredibly useful, enabling me to hunt down some odd errors that were being generated as part of our continuous integration builds and a few spurious errors in our live environments.

However, I was getting annoyed having to remember to import the module into my Powershell session every time I wanted to call the function – so I knocked together a simple autoloader script to handle this for me:

function Autoload {
    $private:AutoLoad = @{
        Modules=@(
            'Xml-Utils',
            'Culture-Utils'
        );
        Paths=@(
            'C:\Cygwin\bin',
            'C:\Cygwin\usr\local\bin'
        );
    }

    foreach ($private:module in $AutoLoad.Modules) {
        Import-Module $module -EA SilentlyContinue
    }

    $private:arr = $env:path.Split(';') | Select -Unique
    foreach ($private:path in $private:AutoLoad.Paths) {
        if ($private:arr -notcontains $private:path) {
            $private:arr += $private:path
        }   
    }
    $env:path = [String]::Join(";", $private:arr)
}

#
# ...
#

Autoload

By changing the Modules array I can force Powershell to automatically load the modules I’m interested in with every console session. In reality, this array is stored as an XML document alongside my Microsoft.PowerShell_profile.ps1 file, but I’ll leave that as an exercise for the reader to implement. The second part of the function allows me to specify paths that I want to add to the environment path variable for each session.

Apologies

Wed, 09 Mar 2011 14:30:44 GMT

Apologies for any duplications or reposting appearing in any RSS readers; I've made the last structural change to the site for a while, so hopefully the permalinks for any posts won't change (again)

Robots Failing In Orchard

Tue, 08 Mar 2011 09:27:58 GMT

I've been getting to grips with the excellent ASP.Net Orchard, and have fully migrated my old blog over to this platform over the last couple of weeks - the issue that I had with the application restarting was due to my hosting provider having throttled the memory restrictions for my Application Pool too far. To their credit, once the issue was discovered they relaxed the restrictions immediately and the site has been working perfectly ever since.

The only stupid little problem that I've had was with enabling Chad Sharf's Robots module which serves 'robots.txt' through the pipeline and provides a simple editor for it through the administration interface. Every time I tried to access 'robots.txt' from my site when the module was enabled I was being given a 404 error.

After several hours pulling my hair out and trawling through the stupidly simple code, the answer hit me.

When I'd originally set up Orchard before uploading to my hosting provider, I'd been using WebMatrix; it turns out that WebMatrix had added a 'robots.txt' for me in the root of the project, which duly got copied over to my hosting provider when I deployed Orchard. This might not seem to be an issue, but Orchard's configuration explicitly turns off all handlers to force all requests through its own routing mechanism:

<handlers accessPolicy="Script">
	<!-- clear all handlers, prevents executing code file extensions, prevents returning any file contents -->
	<clear/>
	<!-- Return 404 for all requests via managed handler. The url routing handler will substitute the mvc request handler when routes match. -->
	<add name="NotFound" path="*" verb="*" type="System.Web.HttpNotFoundHandler" preCondition="integratedMode" requireAccess="Script"/>
</handlers>

The upshot if this meant that (counter-intuitively) if the 'robots.txt' file existed on the filesystem, any request for it would immediately return a 404 error and wouldn't hit the routing mechanism within Orchard - simply deleting the file immediately kicked the module into life.

Validating XML Documents In PowerShell

Wed, 02 Mar 2011 11:14:20 GMT

I came across a problem the other day where a process that relied on several external XML documents was failing due to a combination of factors:

The document had been hand-edited
The document contained UTF-8 characters
The document had no encoding directive or BOM to identify it as containing UTF-8 characters

So, I knocked together the following PowerShell module to validate XML documents from the command line:

function Test-Xml {
    param([string[]]$Path)
    
    begin {
        $xml = new-object System.Xml.XmlDocument
        
        function TestXmlDocument([string]$path) {
            $relativePath = Resolve-Path $path -Relative
            Write-Host -NoNewLine "$relativePath : "
            
            trap [System.Xml.XmlException] { 
                $script:valid = $false
                $script:message = $_.Exception.Message
                continue; 
            }
            
            $script:valid = $true
            $resolvedPath = Resolve-Path $path
            $xml.Load($resolvedPath)
            
            if ($script:valid) {
                Write-Host -ForegroundColor Green "OK"
            } else {
                Write-Host -ForegroundColor Red "Failed - $script:message"
            }
        }
    }
    
    process {
        if ($_ -is [IO.FileInfo]) {
            TestXmlDocument $_.FullName
        } elseif ($_ -is [string]) {
            if (test-path -type Leaf $_) {
                TestXmlDocument $_
            }
        }
    }
    
    end {
        if ($Path) {
          foreach ($aPath in $Path) {
            TestXmlDocument $aPath
          }
        }
    }
}

Export-ModuleMember Test-Xml

The function is implemented so that it can be invoked directly or as a filter. It can therefore be used to check a single file:

Test-Xml fileToCheck.xml

a list of files:

Test-Xml file1.xml, file2.xml, file3.xml

or against a set of files as part of a process:

Get-ChildItems -Recurse -Include *.xml,*.config | Test-Xml

The code is probably not as clean as it could be, but it gets the job done.

Migrating To Orchard

Mon, 28 Feb 2011 19:14:56 GMT

It’s time to jump ship again and move to a new Blog system – this time I’ve settled on Orchard, a .NET CMS system with (amongst other things) a full-featured blogging engine.

Migrating from my previous system (dasBlog) has been fairly straightforward, but not without its little challenges. I’ll detail the main steps I had to take in the hope that it will make life easier for anyone else attempting the same thing.

Using WebMatrix I set up a blank Orchard site on my local machine, and got the basic settings configured for the new site, leaving my existing site up and running on my hosting provider. From the Orchard Gallery link within Orchard itself, I downloaded and enabled the BlogML Module.

I then downloaded the DasBlog <-> BlogML utility and ran it against my local backup of my dasBlog site, generating a BlogML format export. I did an initial test-run importing the BlogML which worked fine, but I quickly hit an issue with all the images that I had embedded in my existing blog posts.

Rather than editing all my existing posts and uploading new images for each one, I hacked together a small bit of code to grab assets from my existing site embed them in the BlogML export as Base64 encoded strings:

XDocument doc = XDocument.Load(@"blog.xml");
XNamespace ns = XNamespace.Get("http://www.blogml.com/2006/09/BlogML");

var posts = doc.Descendants(ns + "post");
var postsWithAttachments = posts.Where(p => p.Descendants(ns + "attachment").Count() > 0);

foreach (var post in postsWithAttachments)
{
	foreach (var attachment in post.Descendants(ns + "attachment"))
	{
		WebClient client = new WebClient();
		var attribute = attachment.Attribute("external-uri").Value;

		Console.Write("{0}: ", attribute);

		byte[] data = null;
		try
		{
			data = client.DownloadData(attribute);
		}
		catch { }

		if (data != null)
		{
			Console.WriteLine("OK");
			attachment.SetAttributeValue("embedded", "true");
			attachment.SetValue(System.Convert.ToBase64String(data));
		}
		else
		{
			Console.WriteLine("Failed");
		}
	}
}

posts.Descendants(ns + "trackback").Cast<XNode>().ToList().ForEach(n => n.Remove());
doc.Save(@"blog2.xml");

As 99.9% of the trackback links in the export were from spam sites, I decided to simply drop them all from the export file. The BlogML plugin within Orchard handled the resulting BlogML file without a problem – I know this is not in any way ideal, especially for very large sites, but it worked well for me; all the images were duly extracted and recreated in the appropriate Media folder.

The only other issue was, I suspect, as a result of my hosting provider; Orchard would continually force me to log back in every 20 or so seconds once the site had been published up to the net. Adding a

<machinekey decryption="AES" validation="SHA1" decryptionkey="..." validationkey="..." />

directive to my web.config seemed to fix (or at least mask) the issue for the time being. There is a useful <machineKey> Generator available to get around the drudgery of having to generate the keys yourself.

And that’s basically it; I’ve got a lot to learn about Orchard, and I’ve got a few ideas for some useful modules that I hope to bring online fairly soon.

Generating 'Recently Added' Playlist with Powershell

Wed, 23 Jun 2010 11:15:05 GMT

A feature that I used to like in Windows Media Player 11 that was dropped in version 12 was the 'Recently Added' view. There is a way to produce an automatic playlist that includes recently added items, but it occurred to me that I use a variety of media players depending on my current whim (sometimes it'll even be a command line instance of mplayer through cygwin) and wouldn't it be great to have an auto-generated 'Recently Added' playlist in a format that any respectable media player would understand - namely M3U.

And besides, I wanted to play around with Powershell.

So, I put together the following Powershell script; something that stumped me for a while was to do with resolving absolute paths to relative paths; my issue was:

resolve-path -relative "E:\Music\Autechre\Quaristice\01 Altibzz.mp3"

would return

.\Autechre\Quaristice\01 Altibzz.mp3

but

resolve-path -relative "E:\Music\Peter Gabriel\Hit Disc 2\14 Downside Up [Live].mp3"

would return absolutely nothing. After returning to the script a few hours later, I realised that the issue was to do with wildcard expansion - Powershell uses '[...]' to match ranges or specified characters (see 'help wildcards' in Powershell). A quick flick through the help pages for resolve-path revealed a '-literalpath' parameter, which means that no wildcard expansion is performed. The following command therefore:

resolve-path -relative -literalpath "E:\Music\Peter Gabriel\Hit Disc 2\14 Downside Up [Live].mp3"

gives

.\Peter Gabriel\Hit Disc 2\14 Downside Up [Live].mp3

as expected.

Just to round things off, I decided to emit extended M3U directives for applications that understand them. I stole the GetMP3MetaData function from Johan Straarup's blog entry which uses an interesting trick by instantiating a Shell.Application COM object and accessing the properties that it exposes on a selected file. From this information I could write out the relevant tag information from the selected files and calculate the length of the file in seconds.

From the Powershell command line, you can run the script as

.\Recently-Added.ps1 | Set-Content "Recently Added.m3u"

By default, it will produce a playlist of MP3 files that were created within the last 14 days; this can be adjusted by specifying the '-Days' parameter. For example, to create a list containing files created within the last 21 days:

.\Recently-Added.ps1 -Days 21

I hope someone finds this useful someday.

#
# Recently-Added.ps1
#
param([int]$Days = 14)
$objShell = New-Object -ComObject Shell.Application

function GetMP3MetaData($path)
{
    $file = split-path $path -leaf
    $path = split-path $path
    $objFolder = $objShell.namespace($path)
    $objFile = $objFolder.parsename($file)
    $result = @{}
    0..266 | % {
        if ($objFolder.getDetailsOf($objFile, $_)) {
            $result[$($objFolder.getDetailsOf($objFolder.items, $_))] = $objFolder.getDetailsOf($objFile, $_)
        }
    }
    return $result
}

"#EXTM3U"
gci -recurse -include *.mp3 | `
    ? { $_.CreationTime -gt (get-date).AddDays($Days * -1) } | `
    % {
        $path = resolve-path -relative -literalpath $_.FullName
        $info = GetMP3MetaData($_)
        $duration = [timespan]$info.Duration
        "#EXTINF:{0},{1} - {2}" -f $duration.TotalSeconds, $info.Artist, $info.Title
        $path
    }

The Story of Little Suck-a-Thumb

Wed, 05 Aug 2009 09:25:32 GMT

One of the highlights of going to visit my Amma as a small boy used to be reading the old hardback copy of "Struwwelpeter: Merry Tales and Funny Pictures" by Heinrich Hoffman – although it was the inspiration for several recurring nightmares, there was something grotesquely compelling about the book that meant I couldn’t stop re-reading it. The idea that any of the stories could have been described as "Merry Tales" or that this could in any way be considered a children's book was (and still is) bizarre.

My favourite story was always "The Story Of Little Suck-a-Thumb"; it’s the completely cold and matter of fact way in which the unfortunate boy’s mother reacts to her son's mutilation at the hands of the tailor and the freakish illustration of the "great, long, red-legged scissor-man" himself leaping in through the open door with his enormous shears that completely captivated me then (and now).

The Story of Little Suck-a-Thumb

One day Mamma said "Conrad dear,
I must go out and leave you here.
But mind now, Conrad, what I say,
Don't suck your thumb while I'm away.
The great tall tailor always comes
To little boys who suck their thumbs;
And ere they dream what he's about,
He takes his great sharp scissors out,
And cuts their thumbs clean off—and then,
You know, they never grow again."
Mamma had scarcely turned her back,
The thumb was in, Alack! Alack!

The door flew open, in he ran,
The great, long, red-legged scissor-man.
Oh! children, see! the tailor's come
And caught out little Suck-a-Thumb.
Snip! Snap! Snip! the scissors go;
And Conrad cries out "Oh! Oh! Oh!"
Snip! Snap! Snip! They go so fast,
That both his thumbs are off at last.

Mamma comes home: there Conrad stands,
And looks quite sad, and shows his hands;
"Ah!" said Mamma, "I knew he'd come
To naughty little Suck-a-Thumb."

The complete nightmare can be downloaded from Project Gutenberg

Custom DS Lite

Thu, 23 Jul 2009 17:22:38 GMT

The hinge on India’s pink DS lite broke the other day, which left the top screen hanging on precariously for dear life, so rather than risk the wrath of an eight year old if the thing did give out I got a replacement case. I opted for a nice purple colour and armed with a trusty triwing screwdriver, miniature screwdriver set and a couple of young helpers I replaced the case.

I opted to keep the original pink DS’s buttons, D-pad and screen decals – I think the end result is quite fetching.

Amusing Ourselves To Death

Fri, 17 Jul 2009 19:06:31 GMT

Just stumbled across this cartoon via B3ta; it makes the case that Aldous Huxley was the more prophetic author compared to George Orwell, contrasting Brave New World against 1984. It’s true that Orwell may have enriched the English language more than Huxley (Newspeak, Big Brother, Room 101, Doublethink etc.), but Huxley may well have had the more accurate vision.

http://fatpita.net/?i=1952

Gig Cancelled

Thu, 18 Jun 2009 12:37:04 GMT

The gig tonight at The Old Ship in Dorcester is not happening – cock up with booking confirmations!

Parmageddon - The origin

Thu, 30 Apr 2009 20:16:04 GMT

The source of the aporkalypse has been identified....

swine.jpg

Shirley Temple Pilots Not Dead Shocker

Tue, 07 Apr 2009 22:12:12 GMT

Yes, it's true; the Shirley Temple Pilots are going to be playing for the first time in ages at Finns in Weymouth on Sat 11th July. It'll be loud.... ;)

ASP.NET MVC 1.0

Fri, 03 Apr 2009 07:11:17 GMT

Are Microsoft really starting to turn a page when it comes to Open Source? Let’s hope so; they’ve just released the source code to the (excellent) ASP.NET MVC framework under the OSI-approved MS-PL license. There's more information over at Scott Guthrie’s blog – I’d particularly recommend reading his ASP.NET MVC PDF tutorial as it gives an excellent overview of ASP.NET MVC itself.

Fake Java enums using C# extension methods

Wed, 25 Mar 2009 10:23:36 GMT

One of the nice features introduced into Java 1.5 that is missing in C# is enum types. In C#, enums are nothing more than a defined set of values with labels, whereas in Java enums can contain methods. I've seen a few attempts to mimic Java enums in C#, but most solutions seem to rely on Attributes to decorate the enum which is fine except that in relative terms, reflection operations are expensive.

C# 3.0 introduced the concept of extension methods which enable you to "add" methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type. As is my wont, I was thinking about this in the shower this morning when I had a eureka moment - surely it should be possible to fake Java enums using C# extension methods?

Using the Java planets example, it didn't take long to whip up the following:

using System;
using System.Collections.Generic;

namespace ScratchPad
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var p = new Program();
            p.Run();
        }

        private void Run()
        {
            double earthWeight = 175;
            double mass = earthWeight / Planet.Earth.SurfaceGravity();

            foreach (Planet planet in Enum.GetValues(typeof(Planet))) {
                Console.WriteLine("Your weight on {0} is {1}", planet, planet.SurfaceWeight(mass));
            }
        }
    }

    public enum Planet
    {
        Mercury,
        Venus,
        Earth,
        Mars,
        Jupiter,
        Saturn,
        Uranus,
        Neptune
    }

    public static class PlanetExtensions
    {
        private static readonly Dictionary planetMap = new Dictionary
          {
              {Planet.Mercury, new PlanetData(3.303e+23, 2.4397e6)},
              {Planet.Venus, new PlanetData(4.869e+24, 6.0518e6)},
              {Planet.Earth, new PlanetData(5.976e+24, 6.37814e6)},
              {Planet.Mars, new PlanetData(6.421e+23, 3.3972e6)},
              {Planet.Jupiter, new PlanetData(1.9e+27,   7.1492e7)},
              {Planet.Saturn, new PlanetData(5.688e+26, 6.0268e7)},
              {Planet.Uranus, new PlanetData(8.686e+25, 2.5559e7)},
              {Planet.Neptune, new PlanetData(1.024e+26, 2.4746e7)}
          };

        private const double G = 6.67300E-11;

        public static double Mass(this Planet planet)
        {
            return GetPlanetData(planet).Mass;
        }

        public static double Radius(this Planet planet)
        {
            return GetPlanetData(planet).Radius;
        }

        public static double SurfaceGravity(this Planet planet)
        {
            PlanetData planetData = GetPlanetData(planet);

            return G * planetData.Mass / (planetData.Radius * planetData.Radius);
        }

        public static double SurfaceWeight(this Planet planet, double mass)
        {
            return mass * SurfaceGravity(planet);
        }

        private static PlanetData GetPlanetData(Planet planet)
        {
            if (!planetMap.ContainsKey(planet))
                throw new ArgumentOutOfRangeException("planet", "Unknown Planet");

            return planetMap[planet];
        }

        #region Nested type: PlanetData

        public class PlanetData
        {            
            public PlanetData(double mass, double radius)
            {
                Mass = mass;
                Radius = radius;
            }

            public double Mass { get; private set; }
            public double Radius { get; private set; }
        }

        #endregion
    }
}

It's all very simple; the only drawback is that you must remember to match any changes to your enum in the associated extension class. Overall, I think this is a pattern I might start to use more often.

Missing

Fri, 13 Mar 2009 12:20:24 GMT

It’s funny how little things can really get under your skin and annoy you; at work, I use a combination of Windows XP and Windows 2003 Server for development and day to day work which is fine, but as I use Vista at home I find that I miss the UI enhancements more and more.

Unlike a lot of people, I seem to have had a rosy experience with Vista; maybe because I didn’t have unrealistic expectations about the OS (I wouldn’t dream of running it on some of the older machines I’ve seen it shoehorned into), and I’ve had some reasonably up to date hardware to run it on. The only real issues that I had with the OS were very early in its life, when some of the third-party drivers for my hardware devices were less than stable – my Hauppauge TV capture card was a prime example. Nowadays though I struggle to find any such issues, even though I’m running the x64 version of Vista.

My particular bugbear at the moment is the XP (and Windows 2003) Start Menu; I’ve got so used to the convenience of the Search function in Vista that not having it available is like having an arm tied behind my back. The amount of times I find myself instinctively pressing the Windows key and then typing “Visual” to find Visual Studio on my development box is ridiculous.

What’s even more annoying is that my work laptop was originally purchased with Vista, which was when downgraded to XP by the IT department...

Tree Power

Sun, 22 Feb 2009 15:50:36 GMT

Came across this video via B3ta – very clever.