Rails Conventions for Fluent NHibernate.cs

    public static class ConventionHelper
    {
        public static string PluralUnderscore(string name)
        {
            return Underscore(Inflector.Net.Inflector.Pluralize(name));
        }

        public static string Underscore(string name)
        {
            var lowered = name.ToLowerInvariant();
            var sb = new StringBuilder();

            for (var i = 0; i < name.Length; i++)
            {
                var a = name.Substring(i, 1);
                var b = lowered.Substring(i, 1);

                var nextIsUpper = true;
                if (i + 1 < name.Length)
                {
                    var next = name.Substring(i + 1, 1);

                    nextIsUpper = IsUppercase(next);
                }
                if (a != b && i != 0 && !nextIsUpper)
                    sb.Append("_");
                sb.Append(b);
            }

            return sb.ToString().Trim();
        }

        public static bool IsUppercase(string str)
        {
            Regex AllCaps = new Regex("[A-Z]");
            return AllCaps.IsMatch(str);
        }
    }

    public class CustomForeignKeyConvention : ForeignKeyConvention
    {
        protected override string GetKeyName(Member property, Type type)
        {
            if (property == null)
                return ConventionHelper.Underscore(type.Name) + "_id";  // many-to-many, one-to-many, join

            return ConventionHelper.Underscore(property.Name) + "_id"; // many-to-one
        }
    }

    public class IdConvention : IIdConvention
    {
        public void Apply(IIdentityInstance instance)
        {
            instance.Column("id");
        }
    }

    public class PropertyConvention : IPropertyConvention
    {
        public void Apply(IPropertyInstance instance)
        {
            instance.Column(ConventionHelper.Underscore(instance.Property.Name));
        }
    }

    public class ReferenceConvention : IReferenceConvention
    {
        public void Apply(IManyToOneInstance instance)
        {
            instance.Column(ConventionHelper.Underscore(instance.Property.Name) + "_id");
        }
    }

    public class TableConvention : IClassConvention
    {
        public void Apply(IClassInstance instance)
        {
            instance.Table(ConventionHelper.PluralUnderscore(instance.EntityType.Name));
        }
    }