I've used a number of pure JavaScript libraries and jQuery plugins to handle client-side validation over the years but I never really liked any of them.  As I often do when I can't find exactly what I want, I built a new one.  

There are certainly libraries out there that cover a broader set of features, but my goal here was to make it dirt simple.  So simple in fact that anyone should be able to read the source and in a few minutes figure out how to make it conform to novel requirements.  The entire framework is shown here in the following gist:

https://gist.github.com/740006.js?file=jquery.validator

As you can see it takes up just over 100 lines and offers out-of-the-box support for a number of standard validation patterns.  However, additional validator methods can be added via the options object.  Below is a usage sample that will make things more clear:

In the above example you can see that adding validation to any input element is as simple as defining a "data-validators" attribute to the element.  The value of this attribute is essentially a JSON string with some syntactic sugar to make it easier on the eyes.  For example, you don't have to surround the whole string with curly braces and if you are defining a validator such as "required" but have no additional options to specify you don't have to do "required:{}" for the JSON to be valid.  If you look at the "expandValidatorString" method in the source you can see that these elements are added dynamically before the JSON is evaluated.

At some point I'll put this up as a repository with more complete documentation but I wanted to get it out there for some feedback before that.  Let me know what you think.

Permalink | Leave a comment  »

I've had the occasion recently to work on some projects in very small teams, just 2 or 3 others at most.  This experience has rekindled in me a joy for this kind of working environment and atmosphere.  There's just something about not being lost in a sea of teammates or (even worse, leading a giant team) that really appeals to me.

As I thought through this more, I began to realize that this isn't simply something that I enjoy, but something that has that "right" feeling about it - it just clicks.  The following is a list of things that I believe are beneficial about operating in small teams and some of the things that flat out cannot be duplicated within a large team structure.

Note: Most of this will be obvious to people and I'm sure it's all been said before, but let me have my fun and blog about it...golf claps at the end would be appreciated.

Low Tolerance for the Silo Effect
When teams are small it's almost impossible for silos to develop.  Even in the face of explicit attempts to make silos, in a small team they just don't materialize.  Whether this is a result of a smaller domain or the low communications barrier, the benefit is clear.  Smaller teams have a much easier time cross training because they hardly have to do it at all, it's a natural phenomena that occurs when living so close to someone else's code.

Nobody Hides Behind the Wall
On large software teams I use the phrase "throw it over the wall" to describe the interaction that often occurs between one part of the team and another.  They don't really care who's on the other side of that wall nor what they're throwing for that matter.  Status just needs to be reported as: We made something, and we threw it over that wall.  The wall could be the one between development and QA, between the business and the BA team, or between the BAs and the developers...point is, it's a wall, and stuff get's chucked.

Clearly this is a terrible way to work and it reduces overall quality because people rely on the shleps on the other side of the wall to complain before they'll deal with their mistakes.  This cannot occur in a small team because the walls are too short for you to throw something over it and still retain the comfortable anonymity that a higher wall would provide.

Sorry: Took that analogy a bit far!

We Don't Need No Stinking Managers
While this is not strictly true all the time, my point is that with small teams the oversight tax is quite minimal.  As a team grows in size the amount of overhead incurred by management rises logarithmically.  By the time you have a team of 20-25 developers you have so many tech leads, architects, and project managers installed that your 2 for 1 pizza coupons are no longer valid.

Management and oversight is important but not at the expense of agility and direct (peer) accountability.  Small teams rarely have this problem and often a single manager can provide adequate oversight for more than one semi-self-governing project.

We Built [more of] That
This one is just my opinion, but when a large team builds an enormous software product the "I made that" quotient per individual is very low.  When a small team builds a substantial software product for their size that same metric goes through the roof.  It is profoundly more satisfying (for me anyway) to be part of a 4 person team who accomplishes the work of 7 over being part of a 23 person team who comes in over budget and delivering less scope.  Again, just my opinion.

Craftsmanship and Apprenticeship <3 Small Teams
This one may be a bit controversial but I believe it's more difficult for mentorship to occur on big teams.  It can happen of course, but the ratio of highly skilled craftsman to more junior developers forces those highly skilled individuals to be spread too thin on large teams.  On a team with one seasoned journeyman and two apprentices the two junior team members will learn a lot more simply because they have more concentrated contact with their mentor...and visa versa.

That's it...I'm sure there are loads more benefits (and joys) that people can identify from working in small teams but these are the ones that came to mind at 1:30 in the morning.  I'm very much looking forward to continuing the trend of working in smaller groups and delivering better software for it.

Permalink | Leave a comment  »

In an effort to increase my personal effectiveness I've recently been experimenting with different productivity techniques.  Over the past couple weeks I've attempted to use the Pomodoro approach to task execution.  I've modified the "official" pattern but tried to stay true to it's intent.  My spin on it consists of the following steps:

Set Up

1. Create a catalog of like sized tasks I want to complete.  These tasks don't have to be related but usually are smaller bits of a larger project.  The catalog is prioritize and ordered.  The tasks don't all have to be the same size but it helps to keep the Pomodoros same duration.

2. Arrange a distraction free environment for the duration of the upcoming Pomodoro.  This means shutting down email, IM, TweetDeck, and closing all potentially distracting browser tabs.  If I'm working in a common area I'll either move to somewhere more secluded or put my headphones in to avoid potential interruption.

3. Make sure the stage is set, meaning, make sure all the necessary software is running and projects are open.  No sense wasting the first two minutes of the cycle opening text editors and spinning up servers, etc.

Execute

4. Set a timer.  For me I'm using the simple Pomodoro Timer app for my iPhone.  This works well for me although it seems some people prefer a physical kitchen timer for this.  I find that 20 or 25 minutes work best, more than that you lose the drive to get to the finish and with less time you don't accomplish enough.

5. Do work!

6. Take a 5 minute break and GOTO step 4 until task catalog is complete.  Obviously you'll want to keep the list manageable.  I would suggest not putting more items in the catalog than you can actually accomplish in a set of sequential Pomodoros as this leads to chronic spillage on to the next task list.  You get a nice mental kick when you throw away a completed list.

It sounds like a lot of setup for just 20 or 25 minutes of heads-down time but the ritual really does put me in the mental space to knock something out.  I'm finding that I can run three Pomodoros with 5 minute breaks before I need a longer break or inevitably get pulled into a meeting or something more distracting.  

Although I haven't yet experienced it, I hear people say good things about employing this technique while pairing as it keeps a virtual carrot in front of the pair and relieves the pressure valve every 20/25 minutes or so.

Permalink | Leave a comment  »

It's been out on the Githubs for a few weeks now, but I wanted to do a quick writeup on NoRMatic.  If you're using MongoDB with .NET or Mono, it's pretty likely that you've come across NoRM, the great driver and LINQ provider for MongoDB.  While NoRM is awesome, it can be a little low-level at times and for Crew we needed a library to abstract a few common bits.

Some of the features that NoRMatic provides:

• ActiveRecord style interface (Save, Delete, GetById methods, etc)
• SoftDelete
• Versioning
• Validation (via DataAnnotations attributes)
• Save and Delete Callbacks (Before/After)
• Global Query Filters
• Basic Auditing (DateUpdated, UpdatedBy)
• Simple Log Listener
• Connection String Provider (to connect models to different databases)

Check out the documentation at the Github page for more information.

Permalink | Leave a comment  »

Permalink | Leave a comment  »

public static class LinqToSqlExtensions {

    public static TEntity GetById(this Table @this, int id)
        where TEntity : class {
        return @this.SingleOrDefault(x => ((IIdentified)x).ID == id);
    }

    public static TEntity Upsert(this Table @this, int id)
        where TEntity : class, new() {

        var entity = @this.SingleOrDefault(x => ((IIdentified)x).ID == id);

        if (entity == null) {
            entity = new TEntity();
            @this.InsertOnSubmit(entity);
        }

        if (entity is IAuditable)
            ((IAuditable) entity).ModifiedDate = DateTime.Now;
        return entity;
    }

    public static TEntity Upsert(this Table @this, Func predicate)
        where TEntity : class, new() {

        var entity = @this.SingleOrDefault(predicate);

        if (entity == null) {
            entity = new TEntity();
            @this.InsertOnSubmit(entity);
        }

        if (entity is IAuditable)
            ((IAuditable) entity).ModifiedDate = DateTime.Now;

        return entity;
    }

    public static void Delete(this Table @this, TEntity entity)
        where TEntity : class {
        @this.DeleteOnSubmit(entity);
    }

    public static void DeleteById(this Table @this, int id)
        where TEntity : class {
        var entity = @this.GetById(id);
        @this.Delete(entity);
    }

    public static void DeleteAll(this Table @this, 
        IEnumerable entities) where TEntity : class {
        entities.ToList().ForEach(e => @this.Delete(e));
    }

    public static void CommitChanges(this DataContext @this, RepositoryContext context) {

        var changeSet = @this.GetChangeSet();

        for (var i = 0; i (TEntity entity, RepositoryContext context, 
        bool isInsert) where TEntity : IAuditable {
        
        entity.ModifiedDate = DateTime.Now;
        entity.ModifiedBy = context.UserID;

        if (isInsert) {
            entity.CreatedDate = DateTime.Now;
            entity.CreatedBy = context.UserID;
        }
    }
}

var thing = DataContext.Things.GetById(3);

var thing = DataContext.Things.Upsert(2);
var anotherThing = DataContext.Things.Upsert(x => x.Name == "That Thing");

DataContext.Things.Delete(thing);
DataContext.Things.DeleteById(3);

public interface IAuditable {
    public DateTime CreatedDate { get; set; }
    public DateTime UpdatedDate { get; set; }
    public int CreatedBy { get; set; }
    public int UpdatedBy { get; set; }
}

public interface IIdentified {
    public int ID { get; set; }
}

partial class Thing : IIdentified, IAuditable { }
public class OtherThing : IIdentified { }
public class LastThing : IAuditable { }

Permalink | Leave a comment  »

Making an application scriptable (particularly in a static language) has historically been difficult. With the advent of the DLR (Dynamic Language Runtime) on the .NET platform it becomes almost trivial to add scripting support to any application. For a recent project I needed the ability to add scripting hooks throughout the application and coupling the DLR with PostSharp AOP attributes made this effort pretty straightforward. Here's how it was done:

Bring in the DLR
The DLR is implemented as a set of plain old DLL's on top of the .NET Framework version 3.5...contrary to popular belief, you do not have to be running VS2010 or .NET 4 to use it.  Simply go to the CodePlex page for the DLR (http://dlr.codeplex.com), grab the source, and compile it.  There are solution files for VS2008 and VS2010. For my purposes I used IronPython as the scripting language but IronRuby is available in the download as well.  To use the DLR your project will need to reference the following assemblies:

• Microsoft.Dynamic.dll
• Microsoft.Scripting.Core.dll
• Microsoft.Scripting.dll

In order to use IronPython, you will also need to reference these:

• IronPython.dll
• IronPython.Modules.dll
• Microsoft.Scripting.ExtensionAttribute.dll

Register the Languages
Now that your project contains all the references it needs it's time to set up the little bit of code needed to host the DLR.  First you'll need to add a few things to your configuration file (App.config or Web.config depending on your project type...this works equally well with either).  Just add the following to the node of your config file:

<section name="microsoft.scripting" 
        type="Microsoft.Scripting.Hosting.Configuration.Section, Microsoft.Scripting, 
                Version=0.9.6.20, Culture=neutral, PublicKeyToken=null" 
        requirePermission="false" />

And add the following somewhere in the root node:

<microsoft.scripting>
    <languages>
        <language names="IronPython;Python;py" 
        extensions=".py" displayName="IronPython 2.6" 
        type="IronPython.Runtime.PythonContext, IronPython, 
        Version=2.6.10920.0, Culture=neutral, PublicKeyToken=null" />
    </languages>
</microsoft.scripting>

This basically just tells the runtime what languages to register, what versions of those languages, and some info about file extensions, etc.

Bring in PostSharp
Now I'm going to skip over to PostSharp for a minute. If you're not familiar with PostSharp you should run over to the website (http://www.postsharp.org) and check it out before continuing. In short, it's an AOP (Aspect Oriented Programming) library for .NET that allows easy injection of cross-cutting concerns through an application primarily via attributes. The 10sec. version of how it works is this...it injects code in a post-compilation step. This sounds scary, but it's not. In fact, this allows it to be extremely fast at runtime even if a small penalty is paid at compile-time. In order to get PostSharp setup, it's a simple download and install. If you don't want to install it on your machine, you can simply bin deploy it but it does require a tweak to your .proj file to get the post-compilation to work. If you want to go that route, you can find instructions here. At this point you will either follow those instructions or if you've installed directly, just include the following assemblies in your project:

• PostSharp.Laos.dll
• PostSharp.Public.dll

The ScriptHook Attribute
PostSharp's primary way of injecting an aspect is through attributes. In our case we're going to inherit from the OnMethodBoundaryAspect attribute in the PostSharp.Laos namespace. This attribute exposes four virtual methods that allow injection of code at different points in the execution of a method:

• OnEntry
• OnExit
• OnException
• OnSuccess

Each of these methods accept a MethodExecutionEventArgs as an argument that provides access (including arguments) to the method on which the attribute is applied. Here's the ScriptHook attribute:

[Serializable]
public class ScriptHookAttribute : OnMethodBoundaryAspect {

    private readonly ScriptEventTypes _scriptEventType;

    public ScriptEventAttribute(ScriptEventTypes scriptEventType) {
        _scriptEventType = scriptEventType;
    }

    public override void OnSuccess(MethodExecutionEventArgs eventArgs) {
        var args = eventArgs.GetReadOnlyArgumentArray();
        ScriptRunner.ExecuteEvent(_scriptEventType, args);
    }
}

For now, ignore the ScriptRunner reference, but notice that I've created an enum (ScriptEventTypes) that distinguishes different "types" of scripts to be run, by types, I mean different usages. At some point you can switch on the type of event that's occurring and change which scripts are loaded or how they are handled, etc. You would use the attribute like this:

[ScriptHook(ScriptEventTypes.ThingSaved)]
public void SaveThing(Thing t) { }

[ScriptHook(ScriptEventTypes.ThingDeleted)]
public void DeleteThing(Thing t) { }

The ScriptRunner
At this point we've got the DLR available and we have the PostSharp attribute that's injecting our hooks. Now we need something to execute our scripts. Enter the ScriptRunner:

public static class ScriptRunner {

    public static void ExecuteEvent(ScriptEventTypes scriptEventType, object[] eventContext) {

    IScriptEvent scriptEvent = null;

    switch (scriptEventType) {
        case ScriptEventTypes.ThingSaved:
            scriptEvent = new ThingSavedScriptEvent();
            break;
        case ScriptEventTypes.ThingDeleted:
            scriptEvent = new ThingDeletedScriptEvent;
            break;
        }

        if (scriptEvent != null) {
            try {
                scriptEvent.ExecuteScripts(eventContext);
            } catch {
                throw new ScriptExecutionExecption();
            }
        }
    }
}

The runner is just a simple static class with a single ExecuteEvent method...it's so simple in fact that it speaks for itself. The one thing to note is the eventContext argument to the ExecuteEvent method. If you look back at the ScriptHook attribute you can see that is' passing an object array from the MethodExecutionEventArgs instance. This object array contains all the arguments to the executing method. So for SaveThing() or DeleteThing() for example the eventContext array contains the instance of Thing that was passed.

The IScriptEvent Classes
Lastly, we need something to actually grab the scripts and execute them in something like the context of the executing method. So that's where our example ThingSavedScriptEvent and ThingDeletedScriptEvent come in to play. Here's an example:

public class ThingSavedScriptEvent : IScriptEvent {

    private readonly ScriptRuntime _scriptRuntime;
    private readonly IThingRepository _thingRepo;

    public ProjectCreatedScriptEvent() {
        _thingRepo = new ThingRepository();
        _scriptRuntime = ScriptRuntime.CreateFromConfiguration();
    }

    public void ExecuteScripts(object[] contextValues) {

        var thing = (Thing)contextValues.SingleOrDefault(x => x is Thing);
        
                var scriptScope = _scriptRuntime.CreateScope();
        scriptScope.SetVariable("thingRepo", _thingRepo);
        scriptScope.SetVariable("thing", thing);

        var script = GetScript();

        var scriptEngine = _scriptRuntime.GetEngine("IronPython");
        scriptEngine.Execute(script, scriptScope);
    }

    private static string GetScript() {

        var script = string.Empty;
        try {
            code = File.ReadAllText(HttpContext.Current.Server.MapPath(
                ConfigSettings.ProjectTemplateStorePath + "ThingSaved.py"));
        } catch (FileNotFoundException) { }
        return script;
    }
}

The ScriptRuntime class is where the DLR magic happens. We create an instance of it and then ask it for an engine that can execute IronPython scripts. ScriptScope is a class used for constructing the scope that the script will have available to it. Here for example we're "passing" the 'thingRepo' and 'thing' variables into the script via the ScriptScope. Lastly, we get the engine from the ScriptRuntime, pass it both the ScriptScope and the literal text of the script. And that's that...pretty easy eh?

Permalink | Leave a comment  »

public interface ITestScope {
    void SetupScope();
    void TeardownScope();
}

public abstract class TestBase {
    public abstract void ScopeSetup();
    public abstract void ScopeTeardown();
}

public static class TestFactory {
    public static TRepository GetRepository() where TRepository : class {}
    public static TController GetController() where TController : Controller {}
}

public class CustomerTestScope : ITestScope {
        
        private ICustomerRepository _customerRepo;
        
        public Customer TestCustomer { get; private set; }
        
        public CustomerTestScope(ICustomerRepository customerRepo) {
                _customerRepo = customerRepo;
        }
        
        public void SetupScope() {
                TestCustomer = _customerRepo.Create();
                // Other complex test setup logic
        }
        
        public void TeardownScope() {
                _customerRepo.Delete(TestCustomer);
                // The reverse of the complex setup logic
        }
}

[TestClass]
public class CustomerRepositoryTests : TestBase {

        private CustomerTestScope _customerScope;
        private ICustomerRepository _customerRepo;

        [TestInitialize]
        public override void ScopeSetup() {
        
                _customerRepo = TestFactory.GetRepository();
        
                _customerScope = new CustomerTestScope(_customerRepo);
                _customerScope.SetupScope();
        }
        
        [TestMethod]
        public void SaveCustomer_ShouldRenameCustomer_WhenNewNameGiven() {
        
                _customerScope.TestCustomer.Name = "New Name";
                _customerRepo.Save(_customerScope.TestCustomer);
                
                var customer = _customerRepo.GetById(_customerScope.TestCustomer.ID);
                
                Assert.IsTrue(customer.Name == "New Name", 
                        "SaveCustomer failed to update customer name.");
        }
        
        [TestCleanup]
        public override void ScopeTeardown() {
                _customerScope.TeardownScope();
        }
}

Permalink | Leave a comment  »

I was listening to a recent Hanselminutes podcast episode in which Scott spoke with Michael Feathers of ObjectMentor on the topic of legacy code. They touched on a number of really effective techniques for approaching a legacy code-base and I wanted to echo some of their thoughts and add a few of my own.

First, the definition of legacy code (as was discussed in the show) is really much broader than the face value of the phrase itself. In reality it’s harder to define “legacy code” than it is to know it when you see it. Generally I know I’m dealing with legacy code when any of the following happen:

1. I’m fearful of making changes…the magic box where this code lives might get angry
2. I’m confused and lost after more than a few clicks of “Go to Definition”
3. I find few or no tests, or the quality of tests is poor
4. There are tests but I get mixed or untrustworthy results from running them
5. I have to write more lines of setup code to write a test than the lines of code that I want to test
6. I can find nobody who will admit to understanding (or writing) this code

Doubtless there are more than just these indicators to tell you that you’re dealing with legacy code, but these are red-flags for sure. So what are some high-level techniques that we can use to help bring legacy code into the present…well, here are a few:

Under The Rug
We’ve all done it at home…there’s that last little bit of something that you missed with the broom. So, you lift up the corner of the living room rug and kick it under there with your foot. While you’re mom probably wouldn’t approve, sometimes with code this can be an acceptable approach – provided you acknowledge what you’re doing. What I mean by sweeping it under the rug is that you wrap a section of “legacy code” in a bit of more modern, testable code. In this way you can continue to use the legacy sections but a cleaner interface can be created for testing.

The Strangler Application
This is a pattern that was introduced to me in the Hanselminutes podcast. The basic premise is an extension of the “Under the Rug” concept. But instead of just wrapping the code in a clean exterior, we actually take that opportunity to slowly “choke” out the old code.

One technique that can be employed to slowly transform the codebase is using the “I” in SOLID…Interface Segregation. Applying one or more interfaces to each legacy class allows you to incrementally swap out implementations with clean, new code.

Embrace Continual Design
One thought that came out in the Hanselminutes episode was that design is never over. And I think this is really important to realize. Even in production/support mode, design is something that needs to be addressed. When extending an application, are we setting it up for continued success and maintainability. When re-factoring something or transforming it to un-legacy code, are we taking care that it won’t regress back into legacy code. If a team is focused on continual design it’s less likely for code to become legacy in the first place.

Posthumous Test Coverage
A third approach to legacy code is by testing the crap out of it. One could even make the argument that this is a pre-requisite to the previous three approaches. Spending a lot of time covering legacy code in tests has two major benefits. First, it helps the developer really understand the intent of the code, it’s style, quirks, and patterns. Secondly, it does what tests do best…helps make code changes safer. If a codebase is adequately covered in tests then making changes becomes less scary and potential regression is reduced.

Forklift
Lastly, there is one approach to legacy code that is rarely mentioned…and rightly so, it’s the most aggressive and can be the most costly. Start over…sometimes it’s the best approach.

Once in my life I had to deal with a massive codebase that had been through many, many, cycles of attempted refactorings. The years had left this poor application in a state of wild and unruly disrepair. After discussing all the options with the client it became evident that actually starting over was the best (and in this case, cheapest) way to accomplish the goal.

Starting over can be daunting but if you attack it in a practical and measured way, and possibly mix it with the other techniques described here it can be liberating. It’s important to have a good requirements phase when starting over, you can’t just look at legacy code and start re-writing it. And you need to have all the trappings of a well staffed project in place as well, including strong QA.

~~

So those are some thoughts on legacy code. As always, I’d appreciate hearing what everyone else thinks…what other techniques have you used?

Permalink | Leave a comment  »

protected void Application_Start(object sender, EventArgs e) {
    Config.AddAction("Show/CurrentDate");
}

public class DateAction : ActionBase {
    public override IResponse Get() {
        return Text(string.Format("The current date is {0}.", DateTime.Now));
    }
}

Permalink | Leave a comment  »

(function($) {
    $.fn.tablePager = function(options) {

        /*
        options = {
        firstBtn: Element,
        prevBtn: Element,
        nextBtn: Element,
        lastBtn: Element,
        indicator: Element,
        sizeSelect: Element,
        pageSize: Number,
        onPageChange: Callback,
        onPageSizeChange: Callback
        };
        */

        var tbl = this;
        var defaults = { pageSize: 10 };
        var opts = $.extend(defaults, options);

        var pageIndex = 0;
        var pageSize = opts.pageSize;
        var rowCount = getRows().length;
        var pageCount = getPageCount();

        function init() {
            bindControlHandlers();
            updatePaging();
            updateIndicator();
        }

        function getRows() {
            return tbl.find("tbody tr");
        }

        function bindControlHandlers() {
            if (opts.firstBtn) { 
                opts.firstBtn.unbind().bind("click", 
                    function() { changePage(0); }); 
            }
            if (opts.prevBtn) { 
                opts.prevBtn.unbind().bind("click", 
                        function() { changePage(pageIndex - 1); }); 
            }
            if (opts.nextBtn) { 
                opts.nextBtn.unbind().bind("click", 
                        function() { changePage(pageIndex + 1); }); 
            }
            if (opts.lastBtn) { 
                opts.lastBtn.unbind().bind("click", 
                        function() { changePage(pageCount - 1); }); 
            }
            if (opts.sizeSelect) { 
                opts.sizeSelect.unbind().bind("change", 
                    function() { changePageSize(parseInt($(this).val())); }); 
            }
        }

        function getPageCount() {
            return (rowCount % pageSize) ? 
                Math.floor(rowCount / pageSize) + 1 : (rowCount / pageSize);
        }

        function changePage(toIndex) {
            if (toIndex >= 0 && toIndex = start && i 

Usage:

var pager = $("#testTable").tablePager({
    firstBtn: $(".first"), // The element that pages to the first page
    prevBtn: $(".prev"), // The element that pages to the previous page
    nextBtn: $(".next"), // The element that pages to the next page
    lastBtn: $(".last"), // The element that pages to the last page
    indicator: $(".curpage"), // The input element that stores the current page (i.e. "1/5")
    sizeSelect: $(".pagesize"), // The select element that indicates the current page size
    pageSize: 5, // The initial page size
    onPageChange: function(newIndex) { alert(newIndex); }, // Page change callback
    onPageSizeChange: function(newSize) { alert(newSize); } // Page size change callback
});

pager.changePage(2); // Causes the page to change from outside the plugin
var pageIndex = pager.getPageIndex(); // Returns the current page index
var pageSize = pager.getPageSize(); // Returns the current page size


And here's some example markup for the pager elements:

First  
Prev  
Next  
Last

  

    5
    10
    20



As you can see it's really simple and flexible.  You can supply any elements you want to the pager.  If you don't supply a first and last button elements for example then those will be ignored, if you don't specify an indicator then that will be ignored too.  The most important thing is that your DOM stays intact, this allows you to continue to manipulate the "hidden" portions of the table (i.e. the stuff not on the current page) without having to access some crazy expando property that other pager plugins use to stash the un-shown portions of the table.

As always, I'd appreciate any feedback.

Permalink | Leave a comment  »

public class CompressAttribute : ActionFilterAttribute {

        public override void OnActionExecuting(ActionExecutingContext filterContext) {

            var encodingsAccepted = filterContext.HttpContext.Request.Headers["Accept-Encoding"];
            if (string.IsNullOrEmpty(encodingsAccepted)) return;

            encodingsAccepted = encodingsAccepted.ToLowerInvariant();
            var response = filterContext.HttpContext.Response;

            if (encodingsAccepted.Contains("deflate")) {
                response.AppendHeader("Content-encoding", "deflate");
                response.Filter = new DeflateStream(response.Filter, CompressionMode.Compress);
            } else if (encodingsAccepted.Contains("gzip")) {
                response.AppendHeader("Content-encoding", "gzip");
                response.Filter = new GZipStream(response.Filter, CompressionMode.Compress);
            }
        }
    }

[Compress]
public class ThingController : Controller { ... }

public class ThingController: Controller {

    [Compress]
    public ActionResult Index() { ... }
}

Permalink | Leave a comment  »

namespace DI {

    internal class InjectionBinder {
        public Type Abstract { get; set; }
        public Type Concrete { get; set; }
        public object[] CtorArgs { get; set; }
    }

    /// 
    /// A lightweight dependency injection tool that supports constructor injection and HttpContext.Session caching.
    /// 
    public static class Injector {

        private const string SessionBindingKey = "__InjectorBindings__";
        private const string SessionCacheKey = "__InjectorCache__";

        private static List _bindings {
            get {
                if (HttpContext.Current.Session[SessionBindingKey] == null)
                    HttpContext.Current.Session[SessionBindingKey] = new List();
                return (List)HttpContext.Current.Session[SessionBindingKey];
            }
            set { HttpContext.Current.Session[SessionBindingKey] = value; }
        }

        private static List> _cache {
            get {
                if (HttpContext.Current.Session[SessionCacheKey] == null)
                    HttpContext.Current.Session[SessionCacheKey] = new List>();
                return (List>)HttpContext.Current.Session[SessionCacheKey];
            }
            set { HttpContext.Current.Session[SessionCacheKey] = value; }
        }

        /// 
        /// Returns a concrete instance of the specified abstract type using the provided bindings and 
        /// attempts to satisfy that type's constructor arguments.
        /// 
        /// The abstract type of the object to initialize.
        /// 
        public static object GetInstance(Type abstractType) {

            // Return the item from the cache if it's in there
            var cache = _cache.ToDictionary(o => o.Key, o => o.Value);
            if (cache.ContainsKey(abstractType))
                return cache[abstractType];

            // If the type is in the bindings, return the concrete
            var foundBinding = _bindings.Find(b => b.Abstract == abstractType);
            if (foundBinding != null)
                return Activator.CreateInstance(foundBinding.Concrete, foundBinding.CtorArgs);

            object obj = null;
            var ctors = abstractType.GetConstructors().ToList();

            // If the type has no constructor, then just create one
            if (ctors.Count == 0)
                return Activator.CreateInstance(abstractType);
            
            // If there are constructors, find one which takes arguments of the types we have binders for
            ctors.ForEach(c => {
                var prms = c.GetParameters().ToList();
                var args = new List();
                var haveBindings = true;
                prms.ForEach(p => {
                    var binding = _bindings.Find(b => b.Abstract == p.ParameterType);
                    if (binding == null) { haveBindings = false; }
                    else { args.Add(Activator.CreateInstance(binding.Concrete, binding.CtorArgs)); }
                });
                if (haveBindings) { obj = Activator.CreateInstance(abstractType, args.ToArray()); }
            });

            return obj;
        }

        /// 
        /// Returns a concrete instance of the specified abstract type using the provided bindings and 
        /// attempts to satisfy that type's constructor arguments.
        /// 
        /// The abstract type of the object to initialize.
        /// 
        public static TAbstract GetInstance() where TAbstract : class {
            return GetInstance(typeof (TAbstract)) as TAbstract;
        }

        /// 
        /// Creates a binding rule between an abstract type and a concrete type.
        /// 
        /// The abstract type for the binding.
        /// The concrete type for the binding
        /// The list of constructor arguments to use when initializing the instance of the concrete type.
        public static void Bind(object[] ctorArgs) {
            var binding = _bindings.Find(b => b.Abstract == typeof(TAbstract));
            if (binding != null) {
                binding.Concrete = typeof(TConcrete);
                binding.CtorArgs = ctorArgs;
            } else {
                _bindings.Add(new InjectionBinder {
                    Abstract = typeof(TAbstract),
                    Concrete = typeof(TConcrete),
                    CtorArgs = ctorArgs
                });
            }
        }

        /// 
        /// Clears all Injector binding rules and empties the internal cache.
        /// 
        public static void Kill() {
            HttpContext.Current.Session[SessionBindingKey] = null;
            HttpContext.Current.Session[SessionCacheKey] = null;
        }
    }
}

private static void BindInjectionContainer() {
    Injector.Kill(); // Clears out previously created bindings and empties the cache

    var currentClient = new Client(); // Doesn't matter...just an example
    var currentUser = new User();
    var currentCulture = "en-US";

    Injector.Bind(new object[] { currentClient, currentCulture });
    Injector.Bind(new object[] { currentClient, currentCulture, currentUser });
    Injector.Bind(new object[] {});
}

var secRepo = Injector.GetInstance();

Permalink | Leave a comment  »

Public Module FormatCurrentFile

    Sub FixServerBlocks()
        Dim selection As TextSelection = DTE.ActiveDocument.Selection
        Dim fixed As String = ""
        Dim regex As String = "\"
        While selection.FindPattern(regex, vsFindOptions.vsFindOptionsRegularExpression)
            selection.ReplacePattern(regex, fixed, vsFindOptions.vsFindOptionsRegularExpression)
        End While
    End Sub

End Module

Permalink | Leave a comment  »

public class InjectionControllerFactory : DefaultControllerFactory {
    protected override IController GetControllerInstance(Type controllerType) {
        return ObjectFactory.GetInstance(controllerType) as Controller;
    }
}

public class InjectionControllerFactory : DefaultControllerFactory {
    protected override IController GetControllerInstance(Type controllerType) {
        if (controllerType != null) {
            return ObjectFactory.GetInstance(controllerType) as Controller;
        return base.GetControllerInstance(controllerType);
    }
}

Permalink | Leave a comment  »

• AreaRouteHelper.cs - This guy's job is to add areas to route mapping.  It allows you to map routes inside areas and also map routes to the "root" or controllers that aren't in an area.
• AreaViewEngine.cs - this just adds patterns so that aspx/ascx views can be found one more level down in the file structure.
• Changes to the global.asax to register the new area engine.
• Changes to how the route table is set up (using AreaRoutHelper methods)

Permalink | Leave a comment  »

Permalink | Leave a comment  »

There are two basic ways to do LIKE operations in LINQ to SQL queries...the easy way and the hard way.  The hard way consists of copious usage of String.StartsWith, String.Contains, and String.EndsWith.  The easy way takes advantage of a handy class called SqlMethods found in the System.Data.Linq.SqlClient namespace.

Using the SqlMethods.Like() method, you can do the following:

var keyword = "Marshmal";
var things = from thing in db.Things
                     where SqlMethods.Like(thing.Name, keyword)
                     select thing;

And if you want to search the start, middle, or end of your string, just tack on the '%' as you would in any normal SQL statement:

var keyword = "mallow";
var things = from thing in db.Things
                     where SqlMethods.Like(thing.Name, "%" + keyword)
                     select thing;

And there you have it...an easy way to find your marshmallows.

Permalink | Leave a comment  »

Anyone that's worked with JavaScript in the browser knows that it's all about events.  And in our daily work with the DOM we use the provided events like "click", "change", and "load" all over the place.  But what if you want to create new events for custom objects that might not even have any associated UI.  Unfortunately, the W3C standard for custom events in JavaScript has spotty implementation across browsers, or none at all in some cases.

So, what are we to do...well...here's a simple implementation of the observer pattern that can help solve the lack of internal support for custom events.  Here's the Observer "classes":

var Observer = function() {
    this.observations = [];
};

var Observation = function(name, func) {
    this.name = name;
    this.func = func;
};

Observer.prototype = {
    observe: function(name, func) {
        var exists = this.observations.findAll(function(i) {
            return i.name == name && i.func == func; }).length > 0;
        if (!exists) { this.observations.push(new Observation(name, func)); }
    },
    unobserve: function(name, func) {
        this.observations.remove(function(i) {
            return i.name == name && i.func == func;
        });
    },
    fire: function(name, data, scope) {
        var funcs = this.observations.findAll(function(i) {
            return i.name == name; });
        funcs.forEach(function(i) { i.func.call(scope || window, data); });
    }
};

First thing you'll notice is methods on the "observations" array like forEach() and findAll().  These methods are added by my set of JavaScript extensions found in a previous post.  You'll also notice that this is very simple...so simple in fact that I'm not going to go through it line-by-line...I'm just going to demonstrate.  Here's how you might use this object:

var Person = function() {

    this.name = "John Doe";
    this.age = 23;
    this.observer = new Observer();
    
    this.changeName = function(newName) {
        this.name = newName;
        this.observer.fire("nameChanged", newName);
    };
    
    this.changeAge = function(newAge) {
        this.age = newAge;
        this.observer.fire("ageChanged", newAge);
    };
};

var p1 = new Person();
var p2 = new Person();

p1.observer.observe("nameChanged", alertNameChanged);
p2.observer.observe("ageChanged", alertAgeChanged);

function alertNameChanged(data) { alert("name changed to: " + data); }
function alertAgeChanged(data) { alert("age changed to: " + data); }

p1.changeName("James Doeson");
p2.changeAge(35);

Super simple...create an observer, observe a few things by name, fire a few things by name.  So now you have a behavior very similar to custom events.  One thing to note is that you can change the scope of the callback by passing a third parameter to the observe() method.  So, if you want this to reference some different object within the callback function, just pass it in.

Permalink | Leave a comment  »

Over the years I've collected a set of useful extensions to the Object, Array, and String constructs in JavaScript and I thought I might publish them.  They are all pretty simple but it's a pain to have to write these over and over for each new project so I just compiled them into on file and off we go.  There are probably improvements that could be made to these methods and new ones to be added so please feel free to share your ideas and I'll incorporate them back in.

ObjUtil.isString(Object)
ObjUtil.isNumber(Object)
ObjUtil.isBoolean(Object)
ObjUtil.isArray(Object)
Object.isFunc(Object)
ObjUtil.isDate(Object)
ObjUtil.isRegEx(Object)

ObjUtil.addOverload(Object, String, Function)
This function adds some pseudo function overloading to JavaScript.  The first argument is the name of the function you'd like to expose and the second is the function to be called using that name.  The limitation here is that the only way to distinguish between method implementations is by the number of arguments (JavaScript does not discriminate by type or name).  Thanks to John Resig for the inspiration for this method.

var obj = { };
obj.addOverload("doSomething", function(a) { ... });
obj.addOverload("doSomething", function(a, b) { ... });
obj.doSomething(a);
obj.doSomething(a, b);

Function.partial()
Adds partial function capability through simple currying.  Thanks to Oliver Steele's Functional.js library for this method.

var add = function(a, b, c) { return a + b + c; };
var addPart = add.partial(1, undefined, 3);
alert(addPart(2)); // alerts 6

Array.copy()
Copies an array's contents to a new array.  Keep in mind that if the array isn't made of simple types like string, number, or boolean that the new array will contain references to the old array's objects.  However, using the copy facilitates sorting and other mutations without affecting the original array.

Array.forEach(Function)
Takes a in a function and calls that function once for every item in the array.

var arr = [1,2,3];
arr.forEach(function(i) { alert(i); });

var arr = [{name:"Bill", age:17}, {name:"Bob", age:27}, {name:"Brian", age:34}];
var item = arr.find(function(i) { return i.name == "Bob"; });

var arr = [{name:"Bill", age:17}, {name:"Bob", age:27}, {name:"Brian", age:34}];
var items = arr.findAll(function(i) { return i.age > 25; });

Array.distinct()
Returns a new array of distinct values from the source array.

Array.min()
Returns the minimum alpha-numeric value in the array.

Array.max()
Returns the maximum alpha-numeric value in the array.

Array.first()
Returns the first item in an array or null if the array is empty.

Array.last() Returns the last item in an array or null if the array is empty.

Array.sortAscending() Sorts the array in ascending numerical or lexicographical order depending on if the first item in the array is a number or not.

Array.sortDescending()
Sorts the array in descending numerical or lexicographical order depending on if the first item in the array is a number or not.

Array.randomize()
Randomizes the order of the array.

Array.count(), Array.count(Function)
Returns the number of items in the array.  If a function is passed in it counts the items matching the functions criteria.

var birds = [{name:"Bill", birdType:"ostrich"}, {name:"Bob", birdType:"penguin"}, {name:"Brian", birdType:"penguin"}];
var penguinCount = birds.count(function(i) { i.birdType == 'penguin'; });

var arrA = [1,2,3,4,5];
var arrB = [3,4,5,6,7,8];
var itmes = arrA.except(arrB);

var arrA = [1,2,3,4,5];
var arrB = [3,4,5,6,7,8];
var itmes = arrA.intersect(arrB);

Array.sum()
Returns the sum of the numeric values in the array.

Array.union(Array)
Returns a new array after joining two others but does not include duplicates.

var arrA = [1,2,3,4,5];
var arrB = [3,4,5,6,7,8];
var newArr = arrA.union(arrB);

Array.getRandom()
Returns a random item from the array.

Array.insertAt(Number, Object)
Adds an item to an array at the specified position (first parameter).

Array.remove(Function)
Removes items matching the functions criteria from the array.

var arr = [{id:1, name:"Bob"}, {id:2, name:"Tom"}, {id:3, name:"Jim"}];
arr.remove(function(i) { return i.name == "Tom"; });

Download JavaScriptExtensions.zip

Note: There is a "tests.html" file which contains examples and unit tests for all of these extensions.  The unit tests are written for FireUnit for FireBug.

Permalink | Leave a comment  »