Brendan Erwin

TDD/BDD Jasmine to Mocha

2012-01-17T00:00:00-05:00

I just got done giving a presentation at the Atlanta JavaScript Meetup Group describing our journey with TDD/BDD in JavaScript using Jasmine and some other tools. I learned a lot:

First, it was a lot of fun getting to talk about this stuff, so thanks a lot folks!

Second, I think I’m going to include a new section at the beginning of all my presentations where I give a bit of background on all the bits and pieces I’ll be using. For instance, a quick overview of CoffeeScript and Vim: what they are, where you can get them, etc. That way I can get that stuff out of the way and hopefully allow people to see my intended content.

Third, I need to focus my message at the beginning and get my goal out there so my audience knows where we are going. “Hand waving” at the beginning isn’t very engaging…

The Content

The presentation was about TDD/BDD in JavaScript. I tried to give a bit of background covering the basic patterns used to write specs and how the Jasmine style is awesome because it can do them all.

Then I went on to describe some of the real-world problems with building big, complex systems. Modularity and the related tools and problems.

Finally, I discussed our journey “through” Jasmine to Mocha (and some related tools) due to the problems we had with Jasmine and our Jasmine tool stack.

Here is my presentation:

Enjoy!

Tools

There was some interest in some of the tools we used as well:

LiveReload to automatically reload the browser when the specs changed.
Guard, Guard-CoffeeScript, and Guard-LiveReload to watch the filesystem for changes.
MacVim, the “Split-browser” branch, by alloy.
Janus, the Vim “Distribution”

I think I’d like to do a presentation digging deep into CoffeeScript. The suggestion came up that a JavaScript vs. CoffeeScript showdown might be a fun format…

Also, I’d like to talk a bit about the OEmbed standard. It has a lot of potential but I think it needs more mind-share.

Upgraded to Octopress

2011-09-28T23:13:00-04:00

Wow. I just upgraded this blog to Octopress and I have to say, it’s pretty amazing.

Octopress is a framework designed by Brandon Mathis for Jekyll, the blog aware static site generator powering Github Pages. To start blogging with Jekyll, you have to write your own HTML templates, CSS, Javascripts and set up your configuration. But with Octopress All of that is already taken care of.

I still get to use markdown for my posts. I still get to use git to manage my content. I still get to host my site as static files on Github Pages. All the best parts about the pervious system are there, but its just so much more awesome.

I’m pretty happy with it. I was getting pretty embarressed with the shoddy state of my previous blog’s markup and javascript. Perhaps this is the jolt I need to get my blogging-muse singing again?

Announcing - accessorize.js

2011-05-26T00:00:00-04:00

I’ve been working on a new open-source project recently. It’s a JavaScript library designed to convert plain-old JavaScript objects (POJOs? Isn’t that one taken already?) into powerful models, full of tasty syntax and functionality.

What does it do?

At its most basic, accessorize.js provides accessor functions over simple JavaScript objects. It creates “JQuery-style” accessor methods which act like a Getter if no parameters are passed in, and like a Setter if a parameter value is passed in : obj.property() - Getter mode

obj.property("new value") - Setter mode

Even though JavaScript has standardized ‘real’ properties, they are not available in any usable form in IE8 and below. Additionally, I believe the syntactic capabilities I’m able to give you offer some pretty compelling reasons to stay with the JQuery-style accessors.

Observable

Accessorized accessors are observable. There is a .subscribe method hanging off each one that can be used to register a function to be called whenever the property value changes:

obj.property.subscribe(function(newValue) { alert("value changed!")});

Chain-able Setter Calls

Accessorized accessors can be set in a call chain, allowing more concise and readable initialization blocks:

obj.property("value")
   .otherProp("other value")
   .stillAnother("and so on")

Underscore Integration

Accessorized accessors are integrated with underscore.js as well. If the Underscore object (simply _) is passed into the accessor, then it triggers a special Getter mode in which the property value is returned already wrapped in the Underscore wrapper. This enables extremely convenient access to the powerful capabilities Underscore provides.

obj.arrayProperty(_).each(function(val){ //do something here });

Fancy Array Accessors

Accessorized array accessors are even more capable. In addition to the other features, including Underscore integration, array accessors also offer indexing variants of the standard accessor calls.

An array accessor can be invoked with the standard Getter mode behavior, but if a number is passed in as a single argument, the array accessor will instead return the value of the array at that index. Like this:

obj.arrayProperty(["hello","world","accessorize.js","is here!"]); //set the array
alert(obj.arrayProperty(2)); //returns "accessorize.js" to the user

The indexing Getter mode also works with Underscore as well:

obj.arrayProperty(1,_) //returns the Underscore wrapped value from that index

Finally, the standard Array methods are promoted to the accessor itself, allowing the accessor to be used as if it was an array in many cases. Methods that cause the contents of the array to change, like .sort will, of course, cause any subscribers to be notified of the change.

obj.arrayProperty.sort(); //sorts the array and notifies any subscribers of the changes

What’s next?

The next major features I’ll be baking in are live DOM binding and integration with Handlebars.js.

The live DOM binding will leverage the observable accessors to make updates to your model’s values automatically appear in your UI.

Handlebars integration will leverage the DOM bindings, allowing you to easily establish live bindings in your templates.

Where is it?

accessorizejs.com is the project’s homepage. You can also go directly to the github site.

It’s written in CoffeeScript, so you’ll have to get one of the compiled releases from the downloads section on GitHub. Or compile it yourself.

inflector_extension is on NuGet now too

2011-04-05T00:00:00-04:00

After getting guard_claws on NuGet yesterday, it was fairly simple to get inflector_extension up there this morning as well.

You can see the package on the NuGet browsing site here. Be sure to let me know how it goes.

guard_claws is on NuGet now

2011-04-04T00:00:00-04:00

I finally got around to updating guard_claws, closing a few issues, and getting it published on the clear winner in the .NET Package Management space: NuGet

You can see my package on the NuGet browsing site here. Be sure to let me know how it goes.

Wiki-Managed Help Command

2010-09-19T00:00:00-04:00

Nu just got (at least in the develop branch, it’ll be released soon) a new help command. It works by taking in a sequence of subjects and displaying an article about them. Something like this: nu help commands install or nu help about authors or even nu help commands install conflicts.

My favorite part about this system is that the content is actually maintained in the GitHub wiki for the project. The new GitHub wikis are now stored as a git repository of files, which opens up all sorts of interesting possibilities. If someone wants to update some existing documentation they simply need to edit the page in the wiki and the next release can include their modifications. If someone wants to add an entirely new subject to the documentation all they need to do is add a page and the next release will pick that up too.

I added the wiki as a submodule of the main project in a docs folder. Then I modified the nu.gemspec to include the docs folder in the gem. At runtime I simply join all the command-line arguments with a dash (-), stick .md on the end and go look in the gem folder for the file. There is a tiny bit of post-processing to remove hyper-link markup and, eventually, to dereference cross-reference ‘See:’ links. There is an issue describing the cross-reference functionality.

The end result of all this is that Nu gets a great documentation resource that is available at runtime, available online, and can be conveniently maintained by more than just the core team. Win, win, and more win.

Here is an example of some of the documentation in the wiki:

And this is what it looks like at run-time:

Dependency Version Leveling

2010-09-09T00:00:00-04:00

There is an open issue for Nu right now referring to “Dependency Leveling”. This is the idea that Nu will find the highest versioned set of dependencies that can work together for a given lib folder. There has been a bit of discussion on it, but since I’m about to start writing code, I thought it would be helpful to describe my thoughts here.

Here is an example from the mailing list (slightly edited):

nu install fluentnhibernate
nu install castle.windsor

FNH is built against NH 2.1.2 and that in turn runs against castle.core 1.1.0.0
Windsor 2.5 then is built against castle.core 2.5 and windsor 2.1 is built against 1.2
So the only compatible version of Windsor and FNH is Windsor 2.0.0.0 + NH 2.1.2.4000

The Ruby Gems package contains enough information to solve this problem but Nu is going to have to recognize when these version conflicts occur and fix them automatically or offer a solution to the user.

In this case, Fluent NHibernate and NHibernate were installed first; Fluent NHibernate will be at the most current version available and NHibernate will be at the most current version available that fits within Fluent’s constraints.

When Castle Windsor is installed, Nu needs to detect that Castle Windsor and NHibernate have a dependency in common, and then recognize that there is a version conflict.

Dependency Version Overlap

The first attempt at resolving the conflict will be to see if a the version requirements for Castle.Core in the installed version of NHibernate and the requested version of Castle Windsor have any versions in common. If so, Nu will install that version of Castle.Core. Nu will not ask for permission to do this.

Newcomer Downgrade

That won’t work in this example though, so Nu will start attempting the same Dependency Version Overlap check on the previous version of Castle Windsor. It will continue checking older and older versions until it reaches a predefined hard-stop or finds a compatible package. In our example, Nu would find that Castle Windsor 2.0.0.0 was compatible and install it. Nu would perform this downgrade automatically, without asking the user for permission.

Incumbent Dependency Downgrade

If the conflicting package is itself a dependency of another package, like NHibernate in our example, the next approach that Nu can try is to see if, by downgrading the conflicting package, it can find a compatible set. In this case, Nu will attempt to downgrade NHibernate, within the dependency requirements of all packages which depend on it, until it finds a compatible set or runs out of available options. For each compatibility check Nu will execute the entire stack of rules, i.e. it will first look for Dependency Version Overlap, and then attempt to downgrade Castle Windsor using Newcomer Downgrade. If Nu is able to find a workable set here it will also do so automatically, since the downgrades were within the declared compatible versions of the installed package (Fluent NHibernate).

Root Package Downgrade

The final approach Nu can take is to try the same set of operations, but attempt downgrades of the packages at the root of the dependency graph. It would, in our example, attempt to downgrade Fluent NHibernate and then run through the entire set of compatibility checks. It would continue downgrading Fluent NHibernate until it found a compatible set or hit a hard-stop. If Nu were able to find a compatible set, it would display the versions to the user and ask if they wanted to rebuild their lib folder to match.

These rules get increasingly expensive to execute, so I think a good approach would be to implement just the first two rules and see how things go. If we run into real-world situations that look like we would like to solve then we can implement the other rules one at a time.

Help!

I would love some thoughts on these rules. Some other examples (real or cooked up) that illustrate the edge conditions are also appreciated. This set of rules is important if Nu is going to be valuable to the .NET community. Like Daniel said, without it Nu “is just a glorified wget.”

Nubular (nu) Project Gets a New Contributor

2010-09-07T00:00:00-04:00

I’m now an official contributor to the Nubular project. I’ll be working on the client software just as I have been, but now I’ll get to push right to the main repository.

I’m enjoying this project a lot. It provides me with a nice outlet for my Ruby envy, gives me something to blog about that is of some interest to others, and lets me contribute back to the open source community a bit.

My choice of hacking focus will be influenced a lot by votes on issues, so if there is a particular feature or bug-fix that you are interested in give it an up-vote! By the way, the vote button is the tiny little triangle near the issue number.

I’ll blog here as new functionality is added, so stay tuned.

Nubular (Nu) Command - Specification

2010-09-06T00:00:00-04:00

UPDATE: Released in v0.2.5.

Nubular (Nu) will be getting a new command soon: specification.

The specification command is intended to provide detailed package information to integrating applications. (Most notably NuForVS.)

It can be used to get package information from a lib folder (default), the local machine’s gem cache (–cache), or from the configured gem servers (–remote).

When querying either the local cache or remote servers, you can specify a particular version with the –version switch, or Nu will simply return the specification for the highest, non-pre-release, version available. It’s not valid to specify a version when querying against a lib folder.

The specification command always returns JSON even if the –json switch is not set, so don’t be surprised if you can’t read the output.

Nubular (Nu) - Using Ruby Gems to manage .Net Libraries

2010-08-29T00:00:00-04:00

I’ve recently started hacking on a pretty cool project. Nubular, or nu, is a front-end over Ruby Gems that is intended to maintain third-party references in a .Net project’s Lib folder.

It utilizes the dependency resolution system already built into Ruby Gems to resolve, download, and install all the pieces and parts needed when adding a third-party reference.

For example, executing nu install fluentnhibernate produces a Lib folder with these packages:

The following packages are installed:
=====================================
    castle.core-1.1.0.0
    castle.dynamicproxy2-2.1.0.0
    fluentnhibernate-1.1.0.685
    log4net-1.2.10.0
    nhibernate-2.1.2.4000
=====================================

(That output was generated with nu report.)

It’s pretty amazing how quickly and easily I can go from 0 to ready to roll with all my standard OSS infrastructure downloaded and waiting for me.

The project’s wiki is here and the mailing list (Google Groups) is here. A list of currently available packages is here.

There is also a Visual Studio Add-In being developed! It should make things wonderfully easy to manage. You can get it here.

Inflector_extension is now a Nubular Gem

2010-08-29T00:00:00-04:00

The wiki is here and the gem is here

inflector_extension provides a nice set of extension methods offering tons of useful inflections of various types. Strings, Ints, Decimals, etc.

Usage

Install it :: nu install inflector_extension
Reference it :: The extension classes are in the global namespace so you don’t need any usings before they are available.
Use it :: "string".InflectTo() or 1.InflectTo() or, for a real blast: 637849590678.InflectTo().Phrase

See the specs for example usages.

In case you are wondering, that big-ass number turns into: "Six Hundred and Thirty Seven Billion, Eight Hundred and Forty Nine Million, Five Hundred and Ninety Thousand, Six Hundred and Seventy Eight"

Rake Tasks for .NET Projects on GitHub

2010-03-06T00:00:00-05:00

I host some open source projects on GitHub and recently put together a few Rake tasks to help with making new releases and deploying their binaries. I call it like: rake release:all TAG=0.0.1

The tasks assume that your solution file will be named like: github_repo_name.sln and at the root of the repository, that the main project will be in a subfolder with the same name as the solution, and that there is a README.markdown at the root of the repository. Here is the structure from one of my projects:

And here is the Rakefile:

A Nice Way to Provide View Helpers for Site Infrastructure

2010-03-06T00:00:00-05:00

In an ASP.NET MVC2 app I’m working on I wanted to add some helpers to my views for concepts like Flash (a la Rails, not Adobe).

The code in my view bases was getting out of hand and had a lot of duplication so I restructured it. I thought it was kind of interesting, so here it is:

You can clone this gist with this clone URL: git://gist.github.com/300398.git

Inflector Extension

2010-02-25T00:00:00-05:00

I just released a little wrapper around the uNHAddins Inflector called Inflector Extension.

It provides a convenient Inflect() extension method on string and int. The int variation only has the “Ordinalize” method but the string version has pretty much all the inflections.

Have fun!

Html.ListBoxFor - Yes, it Needs Two Lists

2010-02-10T00:00:00-05:00

It took me a while to figure this out. As a matter of fact, this is the second post on the subject since the first post was wrong.

In ASP.NET MVC2, the Html.ListBoxFor() method needs two parameters that seem to refer to the same data:

(My example is concerned with a Permission enumeration.)

The behavior of this method just wasn’t very clear at all. It turns out that the first parameter, expression, is intended to reference the model property that contains a list of the selected items. In my case its an IEnumerable<Permission>. Call this parameter “selected items” instead of expression.

The second parameter is an IEnumerable<SelectListItem> called selectList. It is a list of SelectListItems which represents all the possible values that could be selected. Call this parameter “all available items” instead of selectList.

When ListBoxFor() is rendering the list html, it will mark the items as selected when the item’s value is found in both lists. It’s important to not use an IEnumerable<SelectListItem> on the model property.

When the model binders deserialize the form on a POST, the model’s property will only contain entries for those values that were marked as selected.

Once I figured out what the intent was I’m pretty happy with this helper, but boy those parameter names are useless!

How I Structure Tests

2010-02-09T00:00:00-05:00

This came up at work today, and it seems worth posting.

The way I’ve settled on organizing my tests/specs: first, I create general category folders for major architectural chunks of my application. In this example I have Domain and Persistance.

Inside those, if needed, I’ll add further folders to mimic the namespace of the code under test. In this case I have a fairly shallow domain (although it’ll get deaper with time and I’ll restructure the tests).

Finally, for each module I’m specifying, I’ll create a folder and for each method or scenario (if the the behavior is bigger than a single method) I’ll create a fixture. Inside each fixture I’ll list the various specifications.

This all results in a nice organization when running tests and makes it easy to add new specifications as needed.

The Dangers of Operator Overloading

2009-11-16T00:00:00-05:00

It lets things like this happen (one thread, not a broken debugger):

This might help prevent you from bending the spoon:

Guidelines for Overloading Equals() and Operator ==

Consolidating My Identity

2009-05-16T00:00:00-04:00

I like OpenID and have wanted to use it in my day-to-day internet usage. Up until recently I was attempting to use my @gmail.com account but now I have something even better.

The @gmail.com account was OK, but Google’s choice of login URI is weird and impossible to remember. Most OpenID services, myOpenID for instance, give you a URI in the pattern of “username.myopenid.com” to log in with. Easy to remember and, since most login forms let you forgo the https:// part it’s pretty natural to log in.

I took it one better though, my login URI is brendanjerwin.github.com. Now, GitHub is not an OpenID provider, but I’m still able to do this via a neat feature called “delegation.”

Read this: OpenID for non-SuperUsers. I followed the instructions under “Claim Your Blog” and added this to my default.html template:

Note: You do need an account at a real OpenID provider for this to work since it is simply delegation. I use myOpenID as you have probably surmised…

This could be my new favorite thing

2009-05-15T00:00:00-04:00

I was just watching Rob Conery’s screencast on BDD and he showed me a tool that I think might just be my new favorite thing: MSpec/machine.specifications.

It’s a really cool new BDD style executable specification framework which is heavily inspired by RSpec and uses some really neat c# syntax tricks. Not only does it offer a great specification DSL in code, but it, like RSpec, outputs a document that is the specifications document.

Here is a sample snagged out of one of the example projects:

In addition, it has integration with all sorts of great tools. Resharper for instance: it provides a test runner plugin for Resharper 4.1 and 4.5. Here’s a quick screenshot:

And here it is in the code editor window:

It also provides integration with TeamCity, outputting the specifications documentation, with current pass/fail/not-implemented results right there in the specifications.

Go check it out! Watch the screencast and gaze in wonderment!

Helpful links:

- Getting Resharper to play nice with the crazy syntax tricks. - The Machine.Specifications project site on GitHub

Campfire, Now Included

2009-04-30T00:00:00-04:00

Just a little post to mention that I’ve added a Campfire chat room to my site. Now you can drop in for a quick conversation to ask questions about the drivel I post! It’s down at the bottom of each page, along with the subscription buttons: