Mike Nichols - Son Of Nun Technology

ReSharper Rename Namespace Grayed Out

Michael Nichols — Fri, 06 Nov 2009 15:53:55 GMT

I renamed a folder in my project and opened up the solution.

When I tried to fix namespacing in the project using Resharper (ClassView, Ctl+Shft+R, Rename), it would not let me.

I had not rebuilt the solution after having done the rename, so once I did my Rename function was back.

Compiling Mapping using Fluent NHibernate

Michael Nichols — Thu, 29 Oct 2009 23:03:01 GMT

This took me some time to find and work out so I am posting this in case I ever need again. I was getting mapping errors so wanted to see what Fluent NH spits out.

public class FluentNHUtil
{
	string schemaExportPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, 
		"FluentNHMappings");
	[Observation]
	public void compile_mappings_to_disk()
	{
		if (Directory.Exists(schemaExportPath))
			Directory.Delete(schemaExportPath, true);
		Directory.CreateDirectory(schemaExportPath);
		var model = new ReportingModelPersistenceMappingHandler().CreateModel();
		model.CompileMappings();
		model.WriteMappingsTo(schemaExportPath);		
	}
	
}
public class ReportingModelPersistenceMappingHandler
{
	public MappingConfiguration Handle(MappingConfiguration mappingConfiguration)
	{
		mappingConfiguration.AutoMappings.Add(CreateModel());
		mappingConfiguration.HbmMappings.AddFromAssembly(GetType().Assembly);
		return mappingConfiguration;
	}

	public AutoPersistenceModel CreateModel()
	{
		//the Components convention seems redundant but is dealing with an oddity in FluentNH
		return AutoMap.Assembly(GetType().Assembly)
			.Setup(s =>
					{
						s.IsComponentType = type => type.Namespace.Contains("Components");
					})
			.Conventions.Add(
			new ReportingModelIdConvention(),
			DefaultLazy.Never(),
			new PluralizeTableNameConvention(),
			new HasManyDefaultConvention(),
			new LabNumberComponentConvention()
			).Where(t => t.Namespace.Contains(GetNamespaceConvention()) && t.Namespace.Contains("Components")==false);
	}

	private string GetNamespaceConvention()
	{
		return GetType().Namespace + ".Model";
	}
}

NHibernate CurrentSessionContext tip

Michael Nichols — Sun, 25 Oct 2009 04:32:16 GMT

I recently implemented a reporting model in my app (a windows service) and so now have two session factories to manage within a unit of work. Originally, I was using this setting:

<property name="current_session_context_class">thread_static</property>

This was causing the wrong session to get injected into my entities since only one session factory is supported with this setting. So I changed it to this:

<property name="current_session_context_class">call</property>

Now things work as expected. You don’t want to use this on ASP.NET.

Resources

NH docs on Contextual sessions

Virtual Errors From The Crypt

Michael Nichols — Sun, 25 Oct 2009 04:03:38 GMT

Resuming a Win 2K3 session on VMWare 6.5.2 and got an interesting error:

VMware Workstation unrecoverable error: (vmx)
NOT_IMPLEMENTED d:/build/ob/bora-156735/bora/devices/mainmem/mainMemCpt.c:850
A log file is available in "F:\VirtualMachines\VMWare\Windows\Server2003R2\DevBAK\vmware.log". A core file is available in "F:\VirtualMachines\VMWare\Windows\Server2003R2\DevBAK\vmware-vmx-984.dmp". Please request support and include the contents of the log file and core file.
To collect data to submit to VMware support, select Help > About and click "Collect Support Data". You can also run the "vm-support" script in the Workstation folder directly.
We will respond on the basis of your support entitlement.

I started digging around and found some links but none helped resolve my issue. The problem is, my machine was in suspended state. I have a backup but I forgot to git commit before shutting down last night…lame.

So I just deleted the .vmss file in the VM folder that informs the suspended state and the machine boots up fine now.

The Rake’s Progress – Part II

Michael Nichols — Sun, 13 Sep 2009 08:56:00 GMT

Some things I have loved so far about working with rake/ruby:

File enumeration
Blending regular expressions where it makes things more readable
Testability

After checking out lots of other rake files, it is easy to see how much simpler ruby can make things. Along the way I am picking up some idiom’s that (seem) more acceptable and concise.

File Selects

For example, I can do this:

Dir.glob(Path.join(“/path/to/my/files/**”,”*.dll”) + Dir.glob(Path.join(“/path/to/my/files/**”,”*.pdb”)

or better I can use rake’s FileList and a more concise File.join:

FileList.new(Path.join(“path”,”to”,”my”,”files”,”*.{dll,pdb,xml}”))

Directory Ops

I wanted to copy a file structure from one directory to another, but preserving the structure from the original. I had a hard time figuring out the ruby way of doing this, but this seems to do the trick:

FileList.new(File.join(WEB_DIR,"**","*.{spark,asax,aspx,ascx,ashx}"),
	File.join(WEB_DIR,"bin","*.{dll,pdb}"),
	File.join("#{BUILD_CONFIG_DIR}/**", "*")
	).each do |file|			
	path = File.join(DEPLOY_WEB_DIR,file.gsub(WEB_DIR,""))
	target = File.dirname(path)
	File.makedirs(target)			
	cp Pathname.new(file), Pathname.new(target)#bug in ruby for to_str invocation workaround
end

Configuration & Templating

I like the config.yaml RoR convention, so here’s what I came up with. First, two simple classes:

require 'yaml'
class Environment
	attr_accessor :development,:test,:production
	
	def [](name)
		if name.downcase=="development" then development
		elsif name.downcase=="test" then test
		elsif name.downcase=="production" then production
		end	
	end
end

class Configuration
	attr_accessor :service_path, :database_name, :connection_string, :log_level,:static_files_url  ,:dev  	
	# Support templating of member data.
    def get_binding				
		binding
    end
end

Plz…Ignore the crappy [] hack in Environment . These two classes will be read in by ERB like so:

desc "Expand templates"
task :expand => [:clean] do				
	config = YAML::load(File.open(File.join(CONFIG_DIR,"config.yaml")))			
	b = config[ENVIRONMENT].get_binding		
	FileList.new(File.join(CONFIG_DIR,"**","*.{template}"),File.join(INSTALLER_DIR,"**","*.{template}")).each do |file|
		path = ExpandTemplate.new().write(file,b)			
	end				
end

Here’s my config.yaml. Note how we map to the objects I defined above :

--- !ruby/object:Environment 
development: !ruby/object:Configuration    
    database_name: MaterialsTesting_Dev 
    connection_string: my_connection_string 
    log_level: DEBUG 
    static_files_url: http://static.local.com/MaterialsTesting 
test: !ruby/object:Configuration    
    database_name: MaterialsTesting_Test 
    connection_string: my_connection_string 
    log_level: DEBUG 
    static_files_url: http://static.local.com/MaterialsTesting 
production: !ruby/object:Configuration    
    database_name: MaterialsTesting 
    connection_string: my_connection_string 
    log_level: INFO 
    static_files_url: http://static.local.com/MaterialsTesting

Now we can use the ExpandTemplate call:

class ExpandTemplate		
	def write(file,b)							
		template = File.read(file)
		erb = ERB.new(template,0,"%<>")
		output_file_name = File.join(BUILD_DIR,file.gsub(".template",""))		
		output = File.open(output_file_name, 'w') do |file|
			file.puts erb.result(b) 			
		end	
		output_file_name
	end
	
end

So far this has been fun ripping out nant scripts and replacing them with rake.

The Rake’s Progress

Michael Nichols — Mon, 07 Sep 2009 05:40:00 GMT

I have been porting my builds from NAnt to Rake as their complexity has become unmanageable. I couldn’t recall the way I installed Ruby (and associated gems) on my Win 2K3 server and I came across a few issues that I had to resolve to get up and running. Here are some things that helped me.

iconv.dll errors

Running Ruby 1.8.7 required me to follow the steps here . This straightened out an error I was getting from Windows about iconv.dll.

Rake examples

There are a number of good rake (rakefile.rb) samples out there people have been kind enough to share. Here are the ones that were valuable in helping me:

Jon Fuller : He has a link to his googlecode repo of this file and accompanying utilities
Peter Mounce : He has a set of useful tasks for his rake dotnet project here which are definitely worth look at

SQL Quickie - Fix case

Michael Nichols — Fri, 27 Mar 2009 17:07:11 GMT

I needed to quickly (and dirtily) transform rows which were all upper case into pascal cased, so 'I AM OPIE' become 'I Am Opie'.

Here's something I found and ported to a sql function:

CREATE FUNCTION [dbo].[Casing]
(@instring VARCHAR(255))
RETURNS varchar(1000) AS
BEGIN
    --usage: SELECT dbo.Casing('I AM A DOG')
    DECLARE @strptr INT
    DECLARE @strChar char(1)
    DECLARE @outstring varchar(1000)
    SET @outstring = ''
    SET @strptr = 0
    WHILE @strPtr < len(RTRIM(@instring))
    BEGIN
    SET @strptr = @strptr + 1
    SET @strchar = SUBSTRING(@instring,@strptr,1)
    IF @strptr = 1
    SET @outstring = UPPER(@strchar)
    ELSE
    IF SUBSTRING(@instring,(@strptr - 1),1) = ' '
    or SUBSTRING(@instring,(@strptr - 1),1) = ''''
    SET @outstring = SUBSTRING(@outstring,1,@strptr) +
    UPPER(@strchar)
    ELSE
    SET @outstring = SUBSTRING(@outstring,1,@strptr) +
    LOWER(@strchar)
    END
    RETURN @outstring
END

Is Excessive Mapping Of DTOs/ViewObjects to Entities A Code Smell

Michael Nichols — Thu, 05 Mar 2009 07:15:06 GMT

A recent paradigm shift I have been trying to make is to using messaging patterns in my project. One impact of this shift has been a more granular approach to various commands against the domain which somehow changes its state. While I do my best to stick to DDD (Domain Driven Design) modeling patterns and concepts I confess I slide into a CRUD based approach to various actions in the system - lots of data in, lots of data out. This is partly due to the nature of the requirements and partly due to lack of creative thinking regarding what business rules should be enforced on the domain.

As I started to examine where my weak points were in my application I realized I was doing an awful lot of mapping between view objects and domain entities within the Application Service layer which was being called by my Controllers in the web app. This is fine for simple cases but collections of value objects or cross-aggregate references can soon result in too much conditional or procedural code. Then I came across this post by Udi Dahan about getting away from CRUD mentality into a more DDD approach. I had read this before but I didn't "get" it so much. Particularly revealing to me was in the comments where Udi explains a method which is returning a interface that feels 'fluent'.

When I looked over the stinkier parts of my application service code, I recognized I could be more creative in the API for creating the variant objects within my aggregate roots while simultaneously enforcing object creation rules in the domain where they belong. An example would serve to illustrate better.

Consider how I might set the "SomeOptionalValueObject" property on the aggregate root below. Also, let's introduce a Specification that the implementation of the value object which may be assigned is subject to the 'SomeState' of the aggregate (the aptly named "SomeStateHasToBeSatisfiedSpecification").

class AggRoot
{
    public ValueObjectBase SomeOptionalValueObject {get; }
    public SomeState SomeState{get;}
    public void SetSomeOptionalValueObject(SomeOptionalValueObject obj){
       //some stuff
       SomeValueObject = obj;
    }
}

One of the 'rules' of a Value Object in Domain Driven Design is that only transient references to variant objects may be held. That is, we should treat our aggregate root as the entry point and surface to work on for its state and values contributing that state (ie, 'SomeOptionalValueObject' or 'SomeState' above). This simple discipline acts as a funnel for the rules and integrity for the determined roots in our domain and prevents insanity. :)

So how do we perform this simple act of assigning SomeOptionalValueObject to the root which satisfies our SomeStateHasToBeSatisfiedSpecification?

First we might simply put a factory method on the root to create the value object determined by its state and then pass that into our Setter method above:

class AggRoot
{
    //snip
    public ValueObjectBase CreateSomeValueObject(int count,string name, long expectation,TimeSpan duration,/*loads more params*/)
    {
        //some creation logic
        return valueObj;
    }
}

Or perhaps create the value object from the arguments and set it in the same method.

This works if the value object have a variety of implementations, but gets out of hand if we have even a handful of value objects that require different parameters and types.

public class ValueObjectImpl1 : ValueObjectBase
{
   public class ValueObjectImpl1(int count,string name, double amount){}
}
public class ValueObjectImpl2 : ValueObjectBase
{
   public class ValueObjectImpl2(TimeSpan duration,long expectation){}
}
public class ValueObjectImpl3 : ValueObjectBase
{
   public class ValueObjectImpl3(bool isCoarse,TimeSpan duration, double amount){}
}

If there is only one of these value objects I need to build and add to my aggregate root I might create an interface for a builder that is handed to the client to set the value. The implementation of the builder can enforace the SomeStateHasToBeSatisfiedSpecification for our aggregate root. Additionally this will enforce the signatures of the different value object implementations:

interface IValueObjectBuilder
{
    void AddImpl1(int count,string name,double amount);
    void AddImpl2(TimeSpan duration,long expectation);
    void AddImpl3(bool isCoarse,TimeSpan duration,double amount);
}

class AggRoot
{
    IValueObjectBuilder ForOptionalValueObject(){
        //some conditional logic for determining which builder to return
        return builderImplementation;
    }
}

This simple fluency has replaced any property mapping requirement from a client dto => value object and might look now like this:

public void AddSomeValue(object id,ValueObjectImpl1DTO dto)
{
    var aggRoot = repository.Get(id);
    aggRoot.ForOptionalValueObject()
           .AddImpl1(2,"mike",40.32);
    repository.Update(aggRoot);
}

I think this is intention-revealing but I could see also that the method chain might be confusing while browsing the AggRoot. To improve this I might change this to:

class AggRoot
{
    public void SetValueObject(Action<IValueObjectBuilder> with){
      var builder = GetBuilderBasedOnState();
      with(builder);
      SomeOptionalValueObject = builder.Build();
    }
}

Now I only have one method to deal with an I get the bonus of removing the need for the client to call the 'Build' method without resorting to some explicit operator voodoo. Plus I can pass this builder around to do other work internally before pulling the trigger on the build creation method.

This might seem like alot of work but where this starts to shine (I think) is when collections of value objects which all might require different signatures are expected to be added to an aggregate root in one-shot since they are immutable and the collection itself is immutable.

To do this I simply have to create an ISomeValueObjectCollectionBuilder and change the signature on my Set method:

interface ISomeValueObjectCollectionBuilder
{
   void Add(Action<IValueObjectBuilder> with);
}
class AggRoot
{
   //snip
   public void SetValueObject(Action<ISomeValueObjectCollectionBuilder> with)
   {
     var builder = new SomeValueoBjectCollectionBuilder(this);
     with(builder);
     foreach(var item in builder.Items)
     {
         this.items.Add(item);
     }
   }
}

Now my client can navigate this API:

public void AddSomeValueObjects(Impl1ValueObjectDTO[] dtos)
{
   //get root

   aggRoot.SetValueObjects(collection=>
    {
        foreach(var dto in dtos) {
            collection.Add(item=>item.AddImpl1(/*params from dto*/);
            collection.Add(item=>item.AddImpl1(/*params from dto*/);
            collection.Add(item=>item.AddImpl1(/*params from dto*/);
            collection.Add(item=>item.AddImpl1(/*params from dto*/);
         }
    }
}

This simple fluency, along with smarter root factory methods, completely eliminated my need for mappers from DTO objects to their domain variants. Also I found it much simpler to apply specifications on the incoming data AND made creation of these value objects easier to test since it wasn't based on some conditional logic in the service layer. Furthermore, it seems to succeed in meeting the goal of limiting the clients to holding references to the Aggregate Root.

This is of course just one way of enforcing integrity in the domain while translating data from some client in our Application Services using an API that is understandable. A Visitor pattern might be employed to map data based on the IBuilder interface returned by the aggregate root as well without violating separation...but that is another day.

If there are objections to this or perhaps other approaches I'd love to hear them in the comments.

MonoRail 404 Woes

Michael Nichols — Sun, 21 Dec 2008 05:37:51 GMT

Dear Mike In The Future,

If it's been a while since setting up a MonoRail app from ground up, please remember to reference the following assemblies in your web project or at least include them in the /lib folder:

Castle.Components.Common.EmailSender
Castle.Components.Common.TemplateEngine
Castle.Components.Common.Validator
Castle.Components.Common.Binder
Castle.Components.Common.WindsorExtension

Otherwise, you might get a 404 and be confused and consider kicking the nearest small mammal.

Thanks, have a great night.

Mike

Ordering Form Collection Parameters For MonoRail using jQuery

Michael Nichols — Wed, 26 Nov 2008 06:37:42 GMT

On my current app we are using ajax heavily for updating forms, often with the response getting injected into an table or unordered list. The entire form is then posted for the action which will actually change state in the domain.

For example, say we have a 'NewItem' form (and have several properties):

With the action on the controller:

public void myaction([DataBind("newItem")] ItemDTO item)
{
PropertyBag["item"] = item;
RenderView("ViewWithSophisticatedFormattingForItems");
}

This simply pushes back an item using the data provided and jquery appends the table with:

The client will toggle between 'readonly' and 'edit' modes to change data inline.

So this would result in multiple rows of 'item.Name' and 'item.Phone', etc. and the DataBinder will choke if you try this:

public void UpdateToDomain([DataBind("item")] List<ItemDTO> items)
{
//do stuff in domain
}

As magical as MonoRail and her SmartDispatcherController is, she has to know which value belongs to which item in a collection. The lack of indices in the params will therefore cause arrays of 'Value's for a single ItemDTO instance.

My first thought was to do a custom implementation of IParameterBinder + DataBinder combo that parses out the params and tries to split them into multiple instances. This is too difficult though since not all fields may be present for an instance.

So to keep the items in a collection (like table rows or unordered lists) nicely indexed, I created a plugin that handles all the form elements for me. After ajax calls that load data into a table or ul, I can just call the plugin on the rows and all forms elements remain in their appropriate order. Similarly I can unindex forms for posting in the format the action expects. I can similarly just reorder indexes.

This just preserves the id and name convention used throughout monorail (with "_" and "[index]" delimiters respectively). It also changes the 'for' attribute on the label elements for fun.

This is chainable.

To use:

$("table.specimens > tbody tr.edit").indices("on"); //index all rows with class 'edit'
$("table.specimens > tbody tr.edit").indices("off"); //remove index on all rows with class '.edit'
$("table.specimens > tbody tr.edit").indices("ordered"); //ordered existing indices
$("table.specimens > tbody tr.edit").indices();//toggle indexed/nonindexed mode
//specify the parameterName prefix if you are indexing on a nested collection
$("table.specimens > tbody tr.edit").indices("on",{parameterName:'mainclass.nestedObjects'});
//customize whether a new row should increment the index (default is to skip increments on items with class 'repeat-index')
$("table.specimens > tbody tr.edit").indices("on",{isRepeatedIndex:function(){...});

And the plugin:

/***indices plugin for ordering form elements in a group
    @mode (String) :
        "on" (index elements if not already indexed),
        "off" (unindex elements if already indexed),
        "toggle" (toggle between "on" and "off" modes),
        "ordered" (reorder indices of indexed items, or )
    @options (hash) :
        @parameterName (String) : the parameter name to index; if empty, uses the 'name' attribute up to the first '.'
        @isRepeatedIndex (predicate[current item]) : return 'true' to repeat the index (for things like hidden rows, etc); default is a class name 'repeat-index'

***/

(function($) {
    $.fn.indices = function(mode, options) {
        mode = mode || "toggle";
        var defaults = {
            parameterName: "[a-zA-Z0-9]+",
            isRepeatedIndex: function(item) { return $(item).is(".repeat-index"); }
        };
        var opt = $.extend(defaults, options);

        var reIndexedName = new RegExp("^(" + opt.parameterName + ")\\[(\\d+)\\]\\.", "gi");
        var reIndexedId = new RegExp("^(" + opt.parameterName.replace(".", "_") + ")_\\d+\\_", "gi");
        var reNonIndexedName = new RegExp("^(" + opt.parameterName + ")\\.", "gi");
        var reNonIndexedId = new RegExp("^(" + opt.parameterName.replace(".", "_") + ")_", "gi");
        var changeStrategy = null;
        var ndx = -1;

        var unindexElement = function(el, ndx) {
            if (el.name) {
                $(el).attr("name", el.name.replace(reIndexedName, "$1."));
            }
            if (el.id) {
                $(el).attr("id", el.id.replace(reIndexedId, "$1_"));
            }
            if ($(el).attr("for")) {
                $(el).attr("for", $(el).attr("for").replace(reIndexedId, "$1_"));
            }
        };

        var indexElement = function(el, ndx) {
            if (el.name) {
                $(el).attr("name", el.name.replace(reNonIndexedName, "$1[" + ndx + "]."));
            }
            if (el.id) {
                $(el).attr("id", el.id.replace(reNonIndexedId, "$1_" + ndx + "_"));
            }
            if ($(el).attr("for")) {
                $(el).attr("for", $(el).attr("for").replace(reNonIndexedId, "$1_" + ndx + "_"));
            }
        };

        var reindexElement = function(el, ndx) {
            if (el.name) {
                $(el).attr("name", el.name.replace(reIndexedName, "$1[" + ndx + "]."));
            }
            if (el.id) {
                $(el).attr("id", el.id.replace(reIndexedId, "$1_" + ndx + "_"));
            }
            if ($(el).attr("for")) {
                $(el).attr("for", $(el).attr("for").replace(reIndexedId, "$1_" + ndx + "_"));
            }
        };
        return this.each(function(idx, item) {
            if (!opt.isRepeatedIndex(item)) {
                ndx++;
            }

            $(this).find(":input,label").each(function() {

                if (!changeStrategy) {
                    //evaluate only once per collection
                    if (!this.name && !this.id) {
                        //nothing to do here
                        return;
                    }
                    changeStrategy = function() { }; //default empty function
                    var isIndexed = this.name ? reIndexedName.test(this.name) : this.id ? reIndexedId.test(this.id) : false;
                    if (mode == "ordered" && !isIndexed) {
                        mode = "on"; //we already do ordered indexing so just use the 'on' mode
                    }

                    if (isIndexed) {
                        if (mode == "off" || mode == "toggle") {
                            changeStrategy = unindexElement;
                        } else if (mode == "ordered") {
                            changeStrategy = reindexElement
                        }
                    } else {
                        if (mode == "on" || mode == "toggle") {
                            changeStrategy = indexElement;
                        }
                    }
                }
                changeStrategy(this, ndx); //fire

            });
        });

    };

I don't like having to scrub the data like this on the client side, but I really can't think of a way to keep parameters being sent valid while still updating data in small chunks without passing indexes back and forth. Any other approaches would be great to hear!

Considerations For Using PostSharp

Michael Nichols — Mon, 24 Nov 2008 07:19:06 GMT

I recently started using PostSharp for implementing AOP into my current project. It's a great project and really simplifies some specifications we have that could have been cumbersome. Introducing this into an environment that is using NAnt and development using TDD took some exploration for me so I thought I'd log some things I had to overcome.

Building from NAnt

I saw that there was an NAnt task created for PostSharp but I either couldn't get it going, or I couldn't find it ( I can't remember). I ended up just using the command line app included with PostSharp, so I have an NAnt target that invokes the utility from within my project default.build file:

A few things to note here. I had to first make a copy of the assembly I am manipulating and rename it with an 'Pre.assemblyname' prefix (or whatever). The dll was getting locked during the build so PostSharp would complain. The output of PostSharp is 'Post.<assemblyname>' and then I copy that after the utility runs. I think I had the same locking issue that forced me to do this.

Notice I am doing everything in my build directory so I had previously copied over all required PostSharp files to do that when I copy all other dependencies:

TDD Becomes Heavy

The compilation times are considerably larger due to the post-compilation magic. When you are used to almost instant feedback in the IDE this starts out as being an irritation then begins to affect how I write my tests - not good. I will probably pull my aspect related tests into their own test assembly and then target assemblies that are actually used in the app will require some kind of environment condition on the PostSharp targets setup in the .csproj files. I haven't resolved the better approach to take to get around this. I know my own tendency toward impatience will cause me to write bad tests, or not at all, if I have to wait for each rebuild to take so long so I need to keep it quick.

Sorry I am so immature

Michael Nichols — Sun, 23 Nov 2008 08:12:47 GMT

From NH user group:

"I have a "pepe" and I know it is not a proxy"

If this doesn't belong in a software developer's adaptation of Napoleon Dynamite, I don't know what would.

Enabling auto-detection of response type in jQuery

Michael Nichols — Wed, 15 Oct 2008 03:40:39 GMT

Sometimes you don't know what type of document the server is going to return, so it would be nice to have the ajax handler deal with the response as the server is directing it to.

JQuery doesn't have this baked in (I have had a ticket for ages there to implement it), but a workaround is to roll your own handler. The data filter that was introduced in the latest round of jquery is useless since you don't have access to the response object (and thus the header) and doing hacky string parsing was brittle. To replace the current handler, just roll your own httpData function that replaces the native function in jquery.

Using jquery 1.2.6 + here is a patch you can add after the jquery reference on your page:

* patch for dynamic evaluation of xhr responseType to set the dataType on jQuery */
jQuery.extend({
httpData: function( xhr, type, s ) {
        var ct = xhr.getResponseHeader("content-type"),
                xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
                script = type == "script" || !type && ct && ct.indexOf("script") >= 0,
                json = type == "json" || !type && ct && ct.indexOf("json") >= 0,
                data = xml ? xhr.responseXML : xhr.responseText;

                if ( xml && data.documentElement.tagName == "parsererror" )
                    throw "parsererror";

                // Allow a pre-filtering function to sanitize the response
                // s != null is checked to keep backwards compatibility
                if( s && s.dataFilter )
                    data = s.dataFilter( data, type );

                // If the type is "script", eval it in global context
                if ( script )
                    jQuery.globalEval( data );

                // Get the JavaScript object, if JSON is used.
                if ( json )
                    data = eval("(" + data + ")");

                return data;
    }
});

All this is doing is what it already does with xml response types...it sniffs the response header and handles appropriately. Now I can let my server determine whether I am generating just some javascript snippet that should get evaluated or some markup that should be pushed into the page without requiring my client ajax method to state it explicitly.

SVN revision number discrepancy

Michael Nichols — Sun, 07 Sep 2008 21:38:04 GMT

I use VisualSVN for IDE integration of VS.NET and TortoiseSVN. While working on my build script I noticed that while fetching my svn revision number it was different than what was getting reported after a commit within the ide.

I am hardly source control guru so I wasn't sure what to do to track this down.

Turns out I needed to do an svn up at the root directory to bring the revision numbers back in alignment as I found in this (PDF) doc.

When Flushing Goes Bad: Assigned IDs in NHibernate

Michael Nichols — Wed, 30 Jul 2008 02:24:16 GMT

I have an aggregate root that creates another persistent entity and places it in a collection.

Typically, I try to avoid letting the internal id used within an aggregate boundary seep outside, but for the purpose of mapping the relevant instance to the ui data being sent, I needed to get the id and pass it back to the ui.

Using this mapping on the newly created entity:

<class name="AggregateRoot" table="RootsButNotTheBook">
    <!--snip-->
    <set name="ChildEntities" class="ChildEntity" cascade="all"> <!--more-->
</class>
<class name="ChildEntity" table="ChildEntities">
        <id name="Id" type="Guid" >
            <generator class="assigned"/>
        </id>
        
    <!--more mapping-->

and trying this code:

aggregateRoot.CreateChildEntityAndAddToCollection();
session.Update(aggregateRoot);
session.Flush();

Will get me this NHibernate exception:

NHibernate.StaleStateException: Unexpected row count: 0; expected: 1

Why? Well, inside my ChildEntity creation logic, I am generating an id for the entity so NHibernate thinks that it is a previously persisted entity ... but of course it isn't.

To make this work I change my child entity mapping to :

<class name="ChildEntity" table="ChildEntities">
        <id name="Id" type="Guid" >
            <generator class="assigned"/>
        </id>
        <version name="LastModifiedOn" 
                type="timestamp" 
                column="LastModifiedOn" 
                access="nosetter.camelcase" />
    <!--more mapping-->

Adding the Versioning element to my entity now lets NHibernate know how to deal with the entity as it should and the code now works swimmingly.

The Hibernate documentation states:

A version or timestamp property should never be null for a detached instance, so Hibernate will detact any instance with a null version or timestamp as transient, no matter what other unsaved-value strategies are specified. Declaring a nullable version or timestamp property is an easy way to avoid any problems with transitive reattachment in Hibernate, especially useful for people using assigned identifiers or composite keys!

Therefore I actually used a nullable DateTime on my ChildEntity class, but things seemed to work even when I used a non-nullable DateTime, so I am not sure what I am missing there. Let me know if there are any errors in anything I present here...