jxs.me

Katas and TDD

2011-07-09T00:00:00Z

Not long ago, I picked up Uncle Bob Martin’s The Clean Coder and felt like I was called out at every angle on places I could improve. Two areas I’ve severely lacked in are Test Driven Development (TDD) and katas. I found that using Ruby’s Hoe and Zentest have helped eliminate excuses for me to not practice.

Starting Pains

One of my biggest deterrents from starting katas is the boilerplate to get rolling. Being a scripting language, Ruby is helpful for trimming the fat and only working on the meat. However, there is still the friction of laying out code properly and setting up testing. It’s a minor challenge, but enough to put off the effort and say, “I’ll do it later.”

Breaking Ground

Enter Hoe. Hoe is a Ruby gem to help get you rolling quickly. I started out by calling sow, which will make a folder in ~/.hoe_template/default, I copied that folder as as sibling to kata. I took the time to configure it to use Minitest instead of Test::Unit. Now, starting a new kata is as simple as sow -s kata mynewkata, and I’m good to start working. I now have a predefined place for source and tests, and also am able to run my tests quickly using rake test. I understand that there is some time spent to initially configure Hoe, but just knowing that won’t have to deal with that every time I kata is makes it worth it.

Little Circles

Zentest has also been effective in helping me use TDD. It’s easy to slip up and skip running the tests as often as I should. Running autotest increases the frequency of of executing tests, by running on every change of source or test files. It reduces “code, save, run”, to simply “code, save”. This is great while performing the refactor step of TDD, because you don’t have to switch away from your code unless something breaks.

Test Deferred

Test Driven Development is not a new topic to me. From the moment I learned of it, its usefulness has been obvious. Oddly enough, I’ve always behaved as if I was the exception to the rule. I continued writing my code first, and testing sparsely, even though I knew that TDD was effective.

Assessing myself now, I see that my biggest flaw was only learning theory of TDD and not the application of it. I never spent the time to overcome the learning curve. At work, I’d be starting a new project or feature and wouldn’t use TDD because I thought I didn’t have the time to use it. I now recognize two flaws in this train of thinking.

First, honing and growing my skills should not be while working on production code. A baseball pitcher doesn’t learn how to throw a curveball during a game. Rather, he learns it thoroughly during practice time, so that during a game he can use it effectively. As a parallel, I should be using frequent katas to broaden and polish my skill set.

Second, when I think I don’t have time. It’s really claiming I dont have time to learn this technique that would make me a more effective developer. I reflect back to learning Vim. The learning curve is enough to make many shy away, but the productivity that comes from it is enormous. It took me at least two months of constant use to be on par with before it. Now, I am frustrated when I can’t use Vim keybindings. Had I excused myself from learning that in the same way I’ve put off TDD, I would be missing one of the most important tools in my belt.

What I'm Working On - Fubu New

2011-06-11T00:00:00Z

A screencast overview of what I’m currently working on today.

Footage

Testing out screenr today.

Fubu New

I’m currently working on the fubu new command. It’s a command line utility for generating a working FubuMVC project. Yesterday, I spent Open Source Friday working with Sam Merrell on determining a strategy for replacing placeholders in a template project. Sam has done some work with T4, and also threw around the idea of writing a basic templating engine. However, both seem a bit overkill for what’s actually necessary. String.Replace() makes the cut.

At the moment, fubu new only works against a directory. However, adding a default template and simplifying distribution of 3rd party templates (zip, git, etc), is planned.

Spark

As for the issue with Spark, I’ll be diving into that as well. Spark.Parser.ViewLoader is spitting out null for one of its values.

Fubu on Mono

Not covered in the screencast, but also an effort I’ve put forth this morning is attempting to build FubuMVC on mono. It was working at one point and now is failing on FubuMVC.Deployers

FubuBottleDestination.cs(49,75): error CS0584: Internal compiler error: Method not found: 'Bottles.Deployers.Iis.ServerManagerExtensions.CreateSite'.

When that method does, in fact, exist.

C# Websockets with Fleck

2011-05-28T00:00:00Z

In honor of Fleck, a C# websocket library, becoming Mono compatible, I’m finally giving it some exposure.

Fleck was written in response to a lack of lightweight websockets support in C#. It was forked from the Nugget project, and stripped down to the core. The result is an API similar to em-websockets that stays out of your way.

Look familiar?

If you’re in a browser that supports WebSockets (Chrome, Safari, Firefox trunk), go ahead and type a bit. Your keystrokes will be captured, and broadcasted to any other users on the page. If this page is lonely, you can open a second browser window to test it out.

Fleck in Action

Get rolling with Fleck by creating a new WebSocketServer with the address to bind. Call Start() to start the server and configure callbacks for OnOpen, OnClose, and OnMessage.

var allSockets = new List<IWebSocketConnection> ();
var server = new WebSocketServer ("ws://localhost:8081");
server.Start (socket =>
{
  socket.OnOpen = () => allSockets.Add (socket);
  socket.OnClose = () => allSockets.Remove (socket);
  socket.OnMessage = message =>
  {
    foreach (var s in allSockets.ToList())
      s.Send (message);
  };
});
var input = Console.ReadLine ();

In the example, connected sockets are added to an array and broadcasted to when OnMessage is triggered.

Client Side

The client side script listens for keypresses and sends them to the websocket. On receiving a message, which is just a single letter in this case, the corresponding letter will be lit up.

var socket;
var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

function animateCharacter(letter)
{
  var upper = letter.toUpperCase();
  $('#character_' + upper)
    .stop(true,true)
    .animate({ opacity: 1}, 100)
    .animate({ opacity: .2}, 100);
}

function setup()
{
  var target = $('#alphabet');
  for(var i = 0; i <=alphabet.length; i++)
  {
    var char = alphabet.charAt(i);
    target.append('<span id="character_' + char +'">' + char + '</span');
  }
  connect();

  $(document).keypress(function(e){
    var char = String.fromCharCode(e.keyCode);
    socket.send(char);
  });
};

function connect(){
  socket = new WebSocket('ws://localhost:8081');
  socket.onmessage = function(mess) {
    animateCharacter(mess.data);
  };

};

window.onload += setup();

With it all put together, WebSockets makes for a simple way to connect users together through the browser without plugins, polling, or other ugly frameworks.

Logging to CouchDB from C#

2011-05-14T00:00:00Z

Setting up a centralized form of logging can be a pain. CouchDB can help make it easy.

Prerequisites

First, grab the log4net library. It’s common, proven, and makes logging straightforward.

Second, pull down PostLog from github and build

$ git clone https://statianzo@github.com/statianzo/PostLog.git
$ cd PostLog
$ msbuild PostLog.sln

PostLog is an HttpAppender for log4net. It will make an HTTP request for logging events.

Finally, with an instance of CouchDB running, create a database for logging against.

$ curl -X PUT http://localhost:5984/testlog

Use log4net like normal

If your project currently uses, you’re in business. If not, take the following example:

using System;
using log4net.Config;
using log4net;

namespace CouchDBAppenderExample
{
  class MainClass
  {
    public static void Main (string[] args)
    {
      XmlConfigurator.Configure();
      ILog logger = LogManager.GetLogger(typeof(MainClass));
      Console.WriteLine ("Press enter to do it");
      Console.ReadLine();
      try {
        throw new InvalidOperationException("Don't do that!");
      }
      catch(InvalidOperationException e) {
        logger.Error("It blew up", e);
      }
      Console.WriteLine("Done");
      Console.ReadLine();
    }
  }
}

A typical log4net usage. An exception occurs and it gets logged.

Configure log4net

PostLog’s HttpAppender is configured in the log4net app.config section. Several options are available.

uri The location to send the HTTP Request
method The HTTP method to be used (defaults to POST)
useragent The value of the useragent header
format The format to serialize the log data. Options are form, json, and xml
xmlrootname root element tag for xml

A sample configuration is as follows:

<?xml version="1.0"?>
<configuration>
  <configSections>
    <section name="log4net"
             type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
  </configSections>

  <log4net>
    <appender name="HttpAppender" type="PostLog.HttpAppender, PostLog">
      <uri value="http://localhost:5984/testlog" />
      <formatterType value="PostLog.JsonBodyFormatter, PostLog" />
      <parameter>
        <name value="date" />
        <layout type="log4net.Layout.RawTimeStampLayout" />
      </parameter>
      <parameter>
        <name value="level" />
        <layout type="log4net.Layout.PatternLayout">
          <conversionPattern value="%level" />
        </layout>
      </parameter>
      <parameter>
        <name value="message" />
        <layout type="log4net.Layout.PatternLayout">
          <conversionPattern value="%message" />
        </layout>
      </parameter>
      <parameter>
        <name value="exception" />
        <layout type="log4net.Layout.ExceptionLayout" />
      </parameter>
    </appender>
    <root>
      <level value="DEBUG" />
      <appender-ref ref="HttpAppender" />
    </root>
  </log4net>
</configuration>

With the new appender in place, your log statements should start hitting CouchDB.

Views

Now that your log statements are in Couch, you probably want to look at them.

Let’s create a file named logging.json. The file has a view to see all error log statements.

{
  "_id":"_design/logging",
  "language": "javascript",
  "views":
  {
    "error": {
      "map": "function(doc) { if (doc.level === 'ERROR')  emit(doc.date, doc) }"
    },
  }
}

Send it to Couch with curl:

$ curl -T - http://localhost:5984/testlog/_design/logging < logging.json

Now we can view all error statements by calling

$ curl http://localhost:5984/testlog/_design/logging/_view/error

Example

An example project is available on github at: https://github.com/statianzo/CouchDBAppenderExample

Drag and Drop with jQuery

2010-09-20T00:00:00Z

The past week, I’ve been testing out the drag and drop APIs provided by Firefox and Chrome. It’s relatively simple to add a desktop feel to your web apps just by hooking in.

Handling the Drag

Think about what happens you drag and drop a file onto your browser window. Your browser will take the file and attempt to open it. To perform a custom behavior for a drag and drop on a web page, you need to tell the browser, “No thanks. I’ll take it from here.” To do that in Javascript terms there are two calls to make on the event object: stopPropegation() and preventDefault(). The former will stop the event flow to other handlers, and the latter stops the browser from performing the default behavior, opening the file.

function ignoreDrag(e) {
  e.originalEvent.stopPropagation();
  e.originalEvent.preventDefault();
}

In the case that you’re using jQuery, calling the attribute originalEvent is necessary to access stopPropegation() and preventDefault(). You’ll want to bind the ignoreDrag function the dragenter and dragover events of the target.

$('#target')
.bind('dragenter', ignoreDrag)
.bind('dragover', ignoreDrag);
.bind('drop', drop);

You can use these events to style your target as well, to give visual confirmation that a file is able to be dropped on that element.

Using the Drop

Now that you’ve stopped the normal behavior for the drag, you need to do some behavior when a file is dropped. The event argument of the drop event has an attribute called dataTransfer which contains information about what was dropped. For accessing data like text or urls, invoke getData() passing one of the types given in types. For file access use the files attribute to retreive an array of File objects.

function drop(e) {
  ignoreDrag(e);
  var dt = e.originalEvent.dataTransfer;
  var files = dt.files;

  if(dt.files.length > 0){
    var file = dt.files[0];
    alert(file.name);
  }
}

Drop File Here

File objects contain information about the name and size of the file. Also, they can be passed to an XmlHttpRequest and sent as a blob of data. That’s useful for doing an upload of drag and dropped files. Andrea Giammarchi wrote a small library called sendfile for uploading an array of File objects. It could be used as follows:

function drop(e) {
  ignoreDrag(e);
  var dt = e.originalEvent.dataTransfer;
  var droppedFiles = dt.files;

  if(dt.files.length > 0){
    sendMultipleFiles({
      files: droppedFiles,
      url: 'http://mywebsite.com/upload',
      onload: function (){ alert('Done'); }
    });
  }
}

Client Side File Reading in Firefox

Firefox allows you to read from a File object through three different methods: getAsBinary(), getAsDataURL(), and getAsText(encoding). The first will provide raw binary data. getAsDataURL will provide a base-64 formatted string. Finally getAsText will return a string from the encoding provided.

Using getAsDataURL will allow you to populate the src attribute of an img tag with a data string.

function drop(e) {
  ignoreDrag(e);
  var dt = e.originalEvent.dataTransfer;
  var files = dt.files;

  if(dt.files.length > 0){
    $(this).attr('src', files[0].getAsDataURL());
  }
}

If you’re using Firefox (3.6+), drag an image over the image below. The image will be replaced by the image you drop. No need to send data round trip!

GitHub Live via Eventmachine Websockets

2010-09-07T00:00:00Z

Keeping track of commits that have been pushed to GitHub can wind up in many wasteful F5 keystrokes or polling scheme. Using the Post-Receive hook that GitHub provides can turn the tables having it notify us when a change is made. Adding on Websockets can create a browser based display for calls to that hook.

The Hook

Setting up the hook is simple after glancing at post-receive docs. Simply enter the Admin section of your own personal GitHub repository and set up the required service hook. Point it at a url of a web server you own.

Ruby Side

For this, I went with Sinatra because it’s simple to get rolling. Also, I use the em-websockets gem for the purpose of simple web sockets. For further reference on usage see my previous post about them.

require 'bundler'
Bundler.setup
require 'sinatra/base'
require 'yaml'
require 'em-websocket'
require 'open-uri'

GITHUB_URI = 'http://github.com/api/v2/yaml/commits/list/statianzo/emptyrepo/master
SOCKETS = []
EventMachine.run do

  class LivePush < Sinatra::Base
    set :public, File.dirname(__FILE__) + '/public'
    get '/' do
     open(GITHUB_URI) {|s| @commits = YAML::load(s.read)['commits']} unless @commit
     erb :show
    end

    post '/receive' do
      puts "incoming!!"
      if params[:payload]
        @commits = nil
        SOCKETS.each {|s| s.send params[:payload]}
      end
      'Thanks'
    end
  end

  EventMachine::WebSocket.start(:host => '0.0.0.0', :port => 8080) do |ws|
    ws.onopen do
      puts "hello!"
      SOCKETS << ws
    end
    ws.onclose { SOCKETS.delete ws}
  end

  LivePush.run!({:port => 8081})
end

The Sinatra app provides routes for / and /receive. The first is for displaying of the commits and the second takes the content GitHub sends and broadcasts it to all sockets connected.

Javascript Side

The javascript is all about parsing the data and slapping it on the page to make it visible. Using the json parser from [json.org][json] makes this painless.

  function connect(){
    var socket = new WebSocket('ws://yourserver.com:8080');
    socket.onmessage = function(mess) {
      if(mess && mess.data){
        var table = $('#commits');
        var result = JSON.parse(mess.data);
        for(var i = 0; i < result.commits.length; i++){
          var commit = result.commits[i];
          table.append('<tr><td>'+ commit.id + '</td><td>'+
              commit.author.name + '</td><td>' + commit.message + '</td></tr>')
        }
      }
    };
  };
  $(function(){
      connect();
    });

In this example, the results are appended to a <table> on the current page. Very basic, but you can get as fancy as you’d like and pull any of the data that the post-receive hook provides.

And that’s it. Instant feedback about what’s getting pushed to your GitHub repository. I’ll have a demo and the source up soon.

NHibernate in Memory Database Testing with SQLite

2010-08-30T00:00:00Z

One of the pain points that can come along with most tests that hit a database is possibility for inconsistent results. “Just run it again” is not the best mentality to have about it. For example, when someone is running tests locally at the same time your continuous integration is running. The CI fails and you’re faced with the task of figuring out what’s wrong, when it’s really nothing.

We’ve got an ORM to abstract the database from our app. Why not put it to use?

SQLite

Enter SQLite. SQLite is a basic, lightweight SQL database wrapped into a single library. A benefit of its use is that SQLite can create an in-memory database that cleans up after all connections are closed. Its excellent for testing. Starting with a clean slate each test run can provide for consistent, reproducible results.

Prerequisites

NHibernate comes with support for SQLite from the NHibernate.Driver.SQLite20Driver class. However, you must provide two other files for it to work. First, sqlite3.dll, the SQLite unmanaged library; include it in your test project and ensure “copy to output directory” is marked. Second, System.Data.SQLite a managed library that allows ADO.NET to interact with SQLite; include this as a reference in your test project.

A Base Class

The following is a basic example of how to set up a base class for in memory database testing. Any tests that require database interaction should inherit from this class and will have the Session object available. Sessions last as long as each test fixture. Also, typeof(Plan) refers to the type of any of your domain classes.

public class InMemoryDatabaseTest
{
  private static Configuration _configuration;
  protected readonly ISession Session;
  private readonly object _baton = new object();

  private readonly ISessionFactory
    _sessionFactory;

  public InMemoryDatabaseTest()
  {
    if (_configuration == null)
      lock (_baton)
        if (_configuration == null)
        {
          _configuration = new Configuration()
            .SetProperty(Environment.ReleaseConnections, "on_close")
            .SetProperty(Environment.ProxyFactoryFactoryClass,
                         "NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle")
            .SetProperty(Environment.CacheProvider,
                         "NHibernate.Caches.SysCache.SysCacheProvider, NHibernate.Caches.SysCache")
            .SetProperty(Environment.ConnectionDriver, typeof (SQLite20Driver).AssemblyQualifiedName)
            .SetProperty(Environment.ConnectionProvider,
                         "NHibernate.Connection.DriverConnectionProvider")
            .SetProperty(Environment.Isolation, "ReadCommitted")
            .SetProperty(Environment.ConnectionString, "Data Source=:memory:;Version=3;New=True;")
            .SetProperty(Environment.ShowSql, "True")
            .SetProperty(Environment.Dialect, typeof (SQLiteDialect).AssemblyQualifiedName)
            .AddAssembly(Assembly.GetAssembly(typeof(YourDomainObject)));

    _sessionFactory = _configuration.BuildSessionFactory();
    Session = _sessionFactory.OpenSession();
    var schemaExport = new SchemaExport(_configuration);
    schemaExport.Execute(false, true, false, Session.Connection, null);
  }

  public void Dispose()
  {
    Session.Dispose();
  }
}

Support for Schemas

SQLite doesn’t provide native support for schemas. We use SQL Server, and this led to a problem when any of our mappings pointed to tables in anything other than the dbo schema. A simple fix to this is to replace all periods with underscores prior to creating your session factory. This gives the desired behavior without requiring any modification to your mapping files.

if (_configuration == null) {
  _configuration = new Configuration()
  //Configuation...
  foreach (PersistentClass classMapping in _configuration.ClassMappings)
  {
    if (classMapping.Table.Name.Contains("."))
      classMapping.Table.Name = classMapping.Table.Name.Replace(".", "_");
  }
}

Working with AutoMockContainer

If you’re a user of Moq-Contrib’s AutoMockContainer, you can register the Session object into the container to have it provided instead of a mocked session. It’s as simple as adding the following after creating your session object.

MockContainer.Register(Session);

Testing with NHProf

If you use NHibernate Profiler (if you don’t, you should be), your SQLite database interaction can be monitored using that as well. Add an AssemblyInitialize (or your testing framework’s variant) to your InMemoryDatabaseTest class and all interactions will be profiled.

[AssemblyInitialize]
public static void AssemblyInit(TestContext testContext)
{
  NHibernateProfiler.Initialize(); 
}

Having trustworthy results is essential in any test driven development. Using SQLite for testing can help testing scenarios that have consistent results each time.

Websockets using Ruby Eventmachine

2010-08-20T00:00:00Z

HTML5 is loaded with a lot of features that will make the lives of developers much easier and the experience for end users more pleasant as well. Lets take a look one of the new features: WebSockets. We’ll make the magic happen with Ruby’s EventMachine gem.

Mash Some Keys!

Setting Up EventMachine

Using EventMachine for WebSockets is simple with the em-websockets gem. Start an EventMachine.run block and EventMachine::WebSocket.start will do the rest. It provides a socket object that resembles the javascript WebSocket spec with callbacks for onopen, onmessage, and onclose.

require 'eventmachine'
require 'em-websocket'

@sockets = []
EventMachine.run do
  EventMachine::WebSocket.start(:host => '0.0.0.0', :port => 8080) do |socket|
    socket.onopen do
      @sockets << socket
    end
    socket.onmessage do |mess|
      @sockets.each {|s| s.send mess}
    end
    socket.onclose do
      @sockets.delete socket
    end
  end
end

In the example, connected sockets are added to an array and broadcasted to when onmessage is triggered.

Client Side

The client side script listens for keypresses and sends them to the websocket. On receiving a message, which is just a single letter in this case, the corresponding letter will be lit up.

var socket;
var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

function animateCharacter(letter)
{
  var upper = letter.toUpperCase();
  $('#character_' + upper)
    .stop(true,true)
    .animate({ opacity: 1}, 100)
    .animate({ opacity: .2}, 100);
}

function setup()
{
  var target = $('#alphabet');
  for(var i = 0; i <=alphabet.length; i++)
  {
    var char = alphabet.charAt(i);
    target.append('<span id="character_' + char +'">' + char + '</span');
  }
  connect();

  $(document).keypress(function(e){
    var char = String.fromCharCode(e.keyCode);
    socket.send(char);
  });
};

function connect(){
  socket = new WebSocket('ws://h.jxs.me:8080');
  socket.onmessage = function(mess) {
    animateCharacter(mess.data);
  };

};

window.onload += setup();

With it all put together, WebSockets makes for a simple way to connect users together through the browser without plugins, polling, or other ugly frameworks.

ActionContainer: a Dynamic C# Service Agent

2010-08-13T00:00:00Z

ActionContainer is an implementation of the Service Agent pattern in written in C#. It takes advantage of the C# 4.0 dynamic feature to eliminate cluttering your code with empty message classes and also manipulate calls at runtime.

Usage

Usage of ActionContainer is straight forward. Start by creating a class that implements the empty IActionProvider interface with public methods.

public class SimpleProvider : IActionProvider
{
  public void SayHello(string name)
  {
    Console.WriteLine("Hello, {0}", name);
  }

  public string GeneratePassword()
  {
    return "RaNdOmPaSsWoRd";
  }
}

Inject an instance of the ServiceAgent class, and make calls to the registered methods through the ServiceAgent object.

public class Needy : IDependOnSomething
{
    public dynamic ServiceAgent { get; set; }

    public void DoSomething()
    {
        ServiceAgent.SayHello("Buddy");
        string password = ServiceAgent.GeneratePassword();
    }
}

Calling SayHello with a string, will look up a registered method with the name SayHello, takes a string argument, and has a void return type. Same behavior goes for GeneratePassword, except it returns a string.

Looking up methods by name and parameters doesn’t require creating a class (think SayHelloRequest) for each registered action.

The ServiceAgent is also return type aware. In the call string password = ServiceAgent.GeneratePassword();, a search is done for the GeneratePassword that returns string. In this case, the SimpleProvider has the only registered GeneratePassword. Lets say we added another provider, the NumericProvider as follows:

public class NumericProvider: IActionProvider
{
  public int GeneratePassword()
  {
    return 42;
  }
}

Now calls to ServiceAgent.GeneratePassword(); can handle both int and string return types with no special PasswordResponse or NumericPasswordResponse wrapper classes.

string strpwd = ServiceAgent.GeneratePassword(); //returns "RaNdOmPaSsWoRd"
int numpwd = ServiceAgent.GeneratePassword(); //returns 42

Additional Behavior

The default method lookup ability of ActionContainer is just that: the default. ActionContainer provides a hook into its resolving process simply by creating implementations of the IActionListener interface.

public interface IActionListener
{
  bool CanHandle(ActionCallInfo callInfo);
  bool Handle(ActionListenerContext context);
}

The CanHandle method returns true if it has an opinion on the return value of a call. If CanHandle is true, Handle allows the object to manipulate the return value a value.

ActionCallInfo includes the method name, named parameters, unnamed parameters, and expected return type.

Using this information you could add helpful hooks such as a LogListener.

public class LogListener : IActionListener
{
  public bool CanHandle(ActionCallInfo callInfo)
  {
    var arg = callInfo
      .NamedArguments
      .FirstOrDefault(
          x => x.Item1.Equals("log", StringComparison.OrdinalIgnoreCase)
      );
    if (arg == null || !(arg.Item2 is bool) || !(bool)arg.Item2)
      return false;
    var unnamed = callInfo.UnnamedArguments;
    Console.Write("Calling {0}({1}) - Args: ", callInfo.MethodName, callInfo.ReturnType);
    for (int i = 0; i < unnamed.Count; i++)
    {
      var val = unnamed[i];
      Console.Write("input{0}= {1} ", i, val);
    }
    Console.WriteLine();
    return false;

  }

  public bool Handle(ActionListenerContext context)
  {
    return false;
  }
}

The LogListener will watch for an argument named log with the value of true. It will then write to the console the name of the call, return type, and arguments. To put it to use, just use the ServiceAgent as follows:

ServiceAgent.SayHello("Buddy", log: true);
//Output:
//Calling SayHello() - Args: input0= Buddy
//Hello, Buddy

Because the ServiceAgent is a dynamic object, any number of named arguments can be passed to its method calls.

Another possible hook would be a StringTrimListener. Any arguments that are strings can be trimmed before getting passed to the handling method.

public class StringTrimListener : IActionListener
{
  public bool CanHandle(ActionCallInfo callInfo)
  {
    var unnamed = callInfo.UnnamedArguments;
    for (int i =0; i < unnamed.Count; i++)
    {
      var val = unnamed[i] as string;
      if (val != null)
        unnamed[i] = val.Trim();
    }
    return false;
  }

  public bool Handle(ActionListenerContext context)
  {
    return false;
  }
}

No change in code is needed to have calls to the ServiceAgent start using the StringTrimListener. Just make a call on something with a string with hanging spaces.

ServiceAgent.SayHello("       Friend     ", log: true);
//Output:
//Hello, Friend

Things To Keep In Mind

ActionContainer has some requirements that you must keep in mind while using it. Most deal with determining types.

First, when doing variable assignment you must explicitly provide the type when returning values. Using var will result in unfriendly behavior.

var result = ServiceAgent.GeneratePassword(); //BAD!

Second, passing null values as parameters limits lookup. This has to do with null not carrying any type information other than object.

string name = null;
ServiceAgent.SayHello(name); //Less than favorable

Finally, ActionContainer is slow (~10x) compared to direct method calls. Using it in a long running loop will have noticeable performance hits. However, in response to user actions, incoming web request, etc, the difference is negligible.

Getting ActionContainer

It’s on Github. Go and grab it with Git.

$ git clone git://github.com/statianzo/ActionContainer.git

Yellowbrick: an email blogging example

2010-08-06T00:00:00Z

Yellowbrick is a small sinatra blog designed to run on Heroku. It combines several of Heroku’s addons such as MongoHQ and Sendgrid. Using the skeleton Git repository, you can be up and rolling with your own blog similar to that of Tumblr, but configurable down to the last snippet of code.

Why?

Simple: learning. Yellowbrick is an easy way to help get a grasp of programatically dealing with incoming emails. Also, there’s some definite cool factor to running your own custom blog over taking the de facto. Finally, it’s extensible; there’s no limit as to what you can create when the source is yours.

Prerequisites

First of all, Yellowbrick requires that you own a domain and have control over its DNS settings. If you don’t have a Heroku account, Git, and Ruby go grab those now too.

Also, you need the bundler, heroku, and thin gems installed.

$ sudo gem install bundler heroku thin

Getting Some Source

Pull down a copy of the skeleton from Github and enter the directory

$ git clone git://github.com/statianzo/yellowbrick.git
$ cd yellowbrick

Yellowbrick consist of a relatively simple structure. yellowbrick.rb is the core of the app, handling incoming requests. boot.rb loads dependencies and sets up the database. config.ru prepares the app to be run on Heroku.

The models and views directories contain the models and views for the app, respectively.

Running Locally

To start up Yellowbrick locally, you first need to install the Gemfile’s gems

$ bundle install

Second, you need to have the environment variable MONGOHQ_URL pointed to an instance of MongoDB. For a local instance you could use the following:

$ export MONGOHQ_URL='mongodb://localhost/yellowbrick'

And finally, start the thin webserver

$ thin start

If you browse to localhost:3000 you should be met with an empty Yellowbrick blog. To send a sample post, use curl

$ curl -d "subject=MyPost&text=Body+Goes+Here" http://localhost:3000/receive

Refreshing will show your post

Preparing Heroku

Running locally and posting via command line is not too exciting. Blogs are all about web presence. Let’s get some.

Create a new Heroku app using the heroku command line tool. Set up the Sendgrid and MongoHQ addons. Push to the heroku remote repository.

$ heroku create <app_name_here>
$ heroku addons:add mongohq:free
$ heroku addons:add sendgrid:free
$ git push heroku master

Your site should now be usable the same as your local instance. Heroku’s MongoHQ addon automatically sets up the MONGOHQ_URL, and will point to the correct location.

Set Up Sendgrid

Yellowbrick is functional now. However, to have the ability to receive and handle emails, Sendgrid must be configured. Sendgrid provides a feature to parse an email sent to a doma and POST it to a specified url.

If your domain’s DNS settings are controlled by your domain provider, go to their site, and add an additional mx record that points to mx.sendgrid.net.

Retrieve your Sendgrid credentials from Heroku

$ heroku config

Log into the Sendgrid website, enter the Developers – Parse Incoming section where you can set up a hostname to receive emails at (watch.yourdomain.com) and the url to hit when an email arrives, yourapp.heroku.com/receive. It may take up to a half hour while your mx record is getting set up.

Send an email with a subject and body to anything@watch.yourdomain.com, and in moments, the contents should be displayed on your heroku site.

Extending Yellowbrick

As is, Yellowbrick is raw and not secure against anyone else getting their hands on the email address to post to your blog. An initial enhancement could be to add additional restrictions and preventing senders who are not your email using the params[:to].

Read more about what parameters are sent in Sendgrid’s API documentation.