subsonic 3.0.0.4

data/lib/T4 Templates/LinqTemplates/SQLServer.ttinclude

@@ -0,0 +1,349 @@
+<#@ include file="Settings.ttinclude" #>
+<#+
+
+IDataReader GetReader(string sql)
+{
+    SqlConnection conn = new SqlConnection(ConnectionString);
+    SqlCommand cmd = new SqlCommand(sql, conn);
+    conn.Open();
+    return cmd.ExecuteReader(CommandBehavior.CloseConnection);
+}
+
+SqlCommand GetCommand(string sql)
+{
+    SqlConnection conn = new SqlConnection(ConnectionString);
+    SqlCommand cmd = new SqlCommand(sql, conn);
+    conn.Open();
+    return cmd;
+}
+
+const string FKSql=@"SELECT
+        ThisTable  = FK.TABLE_NAME,
+        ThisColumn = CU.COLUMN_NAME,
+        OtherTable  = PK.TABLE_NAME,
+        OtherColumn = PT.COLUMN_NAME, 
+        Constraint_Name = C.CONSTRAINT_NAME,
+        Owner = FK.TABLE_SCHEMA
+    FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS C
+    INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS FK ON C.CONSTRAINT_NAME = FK.CONSTRAINT_NAME
+    INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS PK ON C.UNIQUE_CONSTRAINT_NAME = PK.CONSTRAINT_NAME
+    INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE CU ON C.CONSTRAINT_NAME = CU.CONSTRAINT_NAME
+    INNER JOIN
+        (	
+            SELECT i1.TABLE_NAME, i2.COLUMN_NAME
+            FROM  INFORMATION_SCHEMA.TABLE_CONSTRAINTS i1
+            INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE i2 ON i1.CONSTRAINT_NAME = i2.CONSTRAINT_NAME
+            WHERE i1.CONSTRAINT_TYPE = 'PRIMARY KEY'
+        ) 
+    PT ON PT.TABLE_NAME = PK.TABLE_NAME
+    WHERE FK.Table_NAME=@tableName OR PK.Table_NAME=@tableName";
+
+const string TABLE_SQL=@"SELECT *
+    FROM  INFORMATION_SCHEMA.TABLES
+    WHERE TABLE_TYPE='BASE TABLE'";
+
+const string COLUMN_SQL=@"SELECT 
+        TABLE_CATALOG AS [Database],
+        TABLE_SCHEMA AS Owner, 
+        TABLE_NAME AS TableName, 
+        COLUMN_NAME AS ColumnName, 
+        ORDINAL_POSITION AS OrdinalPosition, 
+        COLUMN_DEFAULT AS DefaultSetting, 
+        IS_NULLABLE AS IsNullable, DATA_TYPE AS DataType, 
+        CHARACTER_MAXIMUM_LENGTH AS MaxLength, 
+        DATETIME_PRECISION AS DatePrecision,
+        COLUMNPROPERTY(object_id('[' + TABLE_SCHEMA + '].[' + TABLE_NAME + ']'), COLUMN_NAME, 'IsIdentity') AS IsIdentity,
+        COLUMNPROPERTY(object_id('[' + TABLE_SCHEMA + '].[' + TABLE_NAME + ']'), COLUMN_NAME, 'IsComputed') as IsComputed
+    FROM  INFORMATION_SCHEMA.COLUMNS
+    WHERE TABLE_NAME=@tableName
+    ORDER BY OrdinalPosition ASC";
+  
+  
+List<SPParam> GetSPParams(string spName)
+{
+    var result = new List<SPParam>();
+    string[] restrictions = new string[4] { DatabaseName, null, spName, null };
+    using(SqlConnection conn = new SqlConnection(ConnectionString))
+	{
+        conn.Open();
+		var sprocs = conn.GetSchema("ProcedureParameters", restrictions);
+		conn.Close();
+
+		foreach(DataRow row in sprocs.Select(string.Empty, "ORDINAL_POSITION"))
+		{
+		    SPParam p = new SPParam();
+			p.SysType = GetSysType(row["DATA_TYPE"].ToString());
+			p.DbType = GetDbType(row["DATA_TYPE"].ToString()).ToString();
+			p.Name = row["PARAMETER_NAME"].ToString().Replace("@", string.Empty);
+			p.CleanName = CleanUp(p.Name);
+			result.Add(p);
+		}
+	}
+	return result;
+}
+
+List<SP> GetSPs()
+{
+    var result = new List<SP>();
+    //pull the SPs
+    
+    DataTable sprocs = null;
+    DataTable parameters = null;
+    
+    using(SqlConnection conn = new SqlConnection(ConnectionString))
+	{
+        conn.Open();
+		sprocs = conn.GetSchema("Procedures");
+		conn.Close();
+	}
+	
+    foreach(DataRow row in sprocs.Rows)
+	{
+	    string spType = row["ROUTINE_TYPE"].ToString();
+        var sp = new SP();
+	    sp.Name = row["ROUTINE_NAME"].ToString();
+	    
+        if(spType == "PROCEDURE" & !sp.Name.StartsWith("sp_"))
+		{
+    	    sp.CleanName = CleanUp(sp.Name);
+            sp.Parameters = GetSPParams(sp.Name);
+            result.Add(sp);        
+        }
+    }
+    return result;
+}
+   
+   
+List<Table> LoadTables()
+{
+    var result = new List<Table>();
+    //pull the tables in a reader
+    using(IDataReader rdr=GetReader(TABLE_SQL))
+	{
+        while(rdr.Read())
+		{
+            Table tbl = new Table();
+            tbl.Name = rdr["TABLE_NAME"].ToString();
+            tbl.Schema = rdr["TABLE_SCHEMA"].ToString();
+            tbl.Columns = LoadColumns(tbl);
+            tbl.PrimaryKey = GetPK(tbl.Name);
+            tbl.CleanName = CleanUp(tbl.Name);
+            tbl.ClassName = Inflector.MakeSingular(tbl.CleanName);
+            tbl.QueryableName = Inflector.MakePlural(tbl.ClassName);
+            
+            //set the PK for the columns
+            var pkColumn = tbl.Columns.SingleOrDefault(x => x.Name.ToLower().Trim() == tbl.PrimaryKey.ToLower().Trim());
+            if(pkColumn != null)
+                pkColumn.IsPK = true;
+            
+            tbl.FKTables = LoadFKTables(tbl.Name);
+            result.Add(tbl);
+        }
+    }
+    
+    foreach(Table tbl in result)
+	{
+        //loop the FK tables and see if there's a match for our FK columns
+        foreach(Column col in tbl.Columns)
+		{
+            col.IsForeignKey=tbl.FKTables.Any(x => x.ThisColumn.Equals(col.Name, StringComparison.InvariantCultureIgnoreCase));
+        }
+    }
+    return result;
+}
+
+List<Column> LoadColumns(Table tbl)
+{
+    var result = new List<Column>();
+    var cmd = GetCommand(COLUMN_SQL);
+    cmd.Parameters.AddWithValue("@tableName", tbl.Name);
+
+    using(IDataReader rdr=cmd.ExecuteReader(CommandBehavior.CloseConnection))
+	{
+        while(rdr.Read())
+		{
+            Column col = new Column();
+            col.Name = rdr["ColumnName"].ToString();
+            col.CleanName = CleanUp(col.Name);
+            col.DataType = rdr["DataType"].ToString();
+            col.SysType = GetSysType(col.DataType);
+            col.DbType = GetDbType(col.DataType);
+            col.AutoIncrement = rdr["IsIdentity"].ToString() == "1";
+            col.IsNullable = rdr["IsNullable"].ToString() == "YES";
+            int.TryParse(rdr["MaxLength"].ToString(), out col.MaxLength);
+            
+            result.Add(col);
+        }
+
+    }
+    return result;
+}
+
+List<FKTable> LoadFKTables(string tableName)
+{
+    //this is a "bi-directional" scheme
+    //which pulls both 1-many and many-1
+
+    var result = new List<FKTable>();
+    var cmd = GetCommand(FKSql);
+    cmd.Parameters.AddWithValue("@tableName", tableName);
+    using(IDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
+	{
+        while(rdr.Read())
+		{
+            FKTable fk = new FKTable();
+            string thisTable = rdr["ThisTable"].ToString();
+            
+            if(tableName.ToLower() == thisTable.ToLower())
+			{
+                fk.ThisTable = rdr["ThisTable"].ToString();
+                fk.ThisColumn = rdr["ThisColumn"].ToString();
+                fk.OtherTable = rdr["OtherTable"].ToString();
+                fk.OtherColumn = rdr["OtherColumn"].ToString();
+            }
+			else
+			{
+                fk.ThisTable = rdr["OtherTable"].ToString();
+                fk.ThisColumn = rdr["OtherColumn"].ToString();
+                fk.OtherTable = rdr["ThisTable"].ToString();
+                fk.OtherColumn = rdr["ThisColumn"].ToString();
+            }
+            
+            fk.OtherClass = Inflector.MakeSingular(CleanUp(fk.OtherTable));
+            fk.OtherQueryable = Inflector.MakePlural(fk.OtherClass);
+            result.Add(fk);
+        }
+    }
+    return result;
+}
+
+string GetPK(string table){
+	
+	string pk = string.Empty;
+	DataTable pkTable = new DataTable();
+    string sql = @"SELECT KCU.COLUMN_NAME 
+        FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE KCU
+        JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC
+        ON KCU.CONSTRAINT_NAME=TC.CONSTRAINT_NAME
+        WHERE TC.CONSTRAINT_TYPE='PRIMARY KEY'
+		AND KCU.TABLE_NAME=@tableName";
+
+    var cmd = GetCommand(sql);
+    cmd.Parameters.AddWithValue("@tableName", table);
+    var result = cmd.ExecuteScalar();
+    cmd.Dispose();
+    if(result != null)
+        pk = result.ToString();    
+
+	return pk;
+}
+
+string GetSysType(string sqlType){
+	string sysType="string";
+	switch (sqlType) 
+	{
+		case "bigint":
+			sysType = "long";
+			break;
+		case "smallint":
+			sysType = "short";
+			break;
+		case "int":
+			sysType = "int";
+			break;
+		case "uniqueidentifier":
+			sysType = "Guid";
+			break;
+		case "smalldatetime":
+		case "datetime":
+			sysType = "DateTime";
+			break;
+		case "float":
+			sysType = "double";
+			break;
+		case "real":
+		case "numeric":
+		case "smallmoney":
+		case "decimal":
+		case "money":
+			sysType = "decimal";
+			break;
+		case "tinyint":
+			sysType = "byte";
+			break;
+		case "bit":
+			sysType = "bool";
+			break;
+		case "image":
+		case "binary":
+		case "varbinary":
+			sysType = "byte[]";
+			break;
+	}
+	return sysType;
+}
+
+DbType GetDbType(string sqlType)
+{
+	switch(sqlType)
+    {
+        case "varchar":
+            return DbType.AnsiString;
+        case "nvarchar":
+            return DbType.String;
+        case "int":
+            return DbType.Int32;
+        case "uniqueidentifier":
+            return DbType.Guid;
+        case "datetime":
+            return DbType.DateTime;
+        case "bigint":
+            return DbType.Int64;
+        case "binary":
+            return DbType.Binary;
+        case "bit":
+            return DbType.Boolean;
+        case "char":
+            return DbType.AnsiStringFixedLength;
+        case "decimal":
+            return DbType.Decimal;
+        case "float":
+            return DbType.Double;
+        case "image":
+            return DbType.Binary;
+        case "money":
+            return DbType.Currency;
+        case "nchar":
+            return DbType.String;
+        case "ntext":
+            return DbType.String;
+        case "numeric":
+            return DbType.Decimal;
+        case "real":
+            return DbType.Single;
+        case "smalldatetime":
+            return DbType.DateTime;
+        case "smallint":
+            return DbType.Int16;
+        case "smallmoney":
+            return DbType.Currency;
+        case "sql_variant":
+            return DbType.String;
+        case "sysname":
+            return DbType.String;
+        case "text":
+            return DbType.AnsiString;
+        case "timestamp":
+            return DbType.Binary;
+        case "tinyint":
+            return DbType.Byte;
+        case "varbinary":
+            return DbType.Binary;
+         case "xml":
+            return DbType.Xml;
+        default:
+            return DbType.AnsiString;
+    }
+}
+
+#>

data/lib/T4 Templates/LinqTemplates/Settings.ttinclude

@@ -0,0 +1,551 @@
+<#@ template language="C#v3.5" debug="True" hostspecific="True" #>
+<#@ assembly name="EnvDTE" #>
+<#@ assembly name="System.Core.dll" #>
+<#@ assembly name="System.Data" #>
+<#@ assembly name="System.Xml" #>
+<#@ assembly name="System.Configuration" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ import namespace="System.Data" #>
+<#@ import namespace="System.Data.SqlClient" #>
+<#@ import namespace="System.Data.Common" #>
+<#@ import namespace="System.Diagnostics" #>
+<#@ import namespace="System.Globalization" #>
+<#@ import namespace="System.IO" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Text.RegularExpressions" #>
+<#@ import namespace="System.Configuration" #>
+
+<#+
+
+    const string Namespace = "GMN.Data.WordPress";
+    const string ConnectionStringName = "GmnWpMu";
+    
+    //This is the name of your database and is used in naming
+    //the repository. By default we set it to the connection string name
+    const string DatabaseName = "GmnWpMu";
+
+    const bool TreatTinyint1AsBool = false;
+
+    //this is a list of tables you don't want generated
+    string[] ExcludeTables = new string[]{
+    "sysdiagrams",
+    "BuildVersion",
+    };
+
+    string CleanUp(string tableName){
+	    string result=tableName;
+    	
+	    //strip blanks
+	    result=result.Replace(" ","");
+    	
+	    //put your logic here...
+    	
+	    return result;
+    }
+    string CheckNullable(Column col){
+        string result="";
+        if(col.IsNullable && col.SysType !="byte[]" && col.SysType !="string")
+            result="?";
+        return result;
+    }
+    string GetConnectionString(string connectionStringName){
+        var _CurrentProject = GetCurrentProject();
+        
+        string result="";
+        ExeConfigurationFileMap configFile = new ExeConfigurationFileMap();
+        configFile.ExeConfigFilename = GetConfigPath();
+
+        if (string.IsNullOrEmpty(configFile.ExeConfigFilename))
+            throw new ArgumentNullException("The project does not contain App.config or Web.config file.");
+        
+        
+        var config = System.Configuration.ConfigurationManager.OpenMappedExeConfiguration(configFile, ConfigurationUserLevel.None);
+        var connSection=config.ConnectionStrings;
+
+        //if the connectionString is empty - which is the defauls
+        //look for count-1 - this is the last connection string
+        //and takes into account AppServices and LocalSqlServer
+        if(string.IsNullOrEmpty(connectionStringName)){
+            if(connSection.ConnectionStrings.Count>1){
+                result=connSection.ConnectionStrings[connSection.ConnectionStrings.Count-1].ConnectionString;
+            }            
+        }else{
+            try{
+                result=connSection.ConnectionStrings[connectionStringName].ConnectionString;
+            }catch{
+                result="There is no connection string name called '"+connectionStringName+"'";
+            }
+        }
+        
+        return result;
+    }
+
+    string _connectionString="";
+    public string ConnectionString{
+	    get {
+	        if(String.IsNullOrEmpty(_connectionString)){
+                
+                _connectionString=GetConnectionString(ConnectionStringName);
+		        
+	        }
+    	        
+	        if(_connectionString.Contains("|DataDirectory|")){
+	            //have to replace it
+	            string dataFilePath=GetDataDirectory();
+	            _connectionString=_connectionString.Replace("|DataDirectory|",dataFilePath);
+	        }    
+    	        
+	        return _connectionString;
+	    }
+    }
+
+    public EnvDTE.Project GetCurrentProject()  {
+  
+        IServiceProvider _ServiceProvider = (IServiceProvider)Host;
+        if (_ServiceProvider == null)
+            throw new Exception("Host property returned unexpected value (null)");
+		
+        EnvDTE.DTE dte = (EnvDTE.DTE)_ServiceProvider.GetService(typeof(EnvDTE.DTE));
+        if (dte == null)
+            throw new Exception("Unable to retrieve EnvDTE.DTE");
+		
+        Array activeSolutionProjects = (Array)dte.ActiveSolutionProjects;
+        if (activeSolutionProjects == null)
+            throw new Exception("DTE.ActiveSolutionProjects returned null");
+		
+        EnvDTE.Project dteProject = (EnvDTE.Project)activeSolutionProjects.GetValue(0);
+        if (dteProject == null)
+            throw new Exception("DTE.ActiveSolutionProjects[0] returned null");
+		
+        return dteProject;
+
+    }
+    
+    private string GetProjectPath()
+    {
+        EnvDTE.Project project = GetCurrentProject();
+        System.IO.FileInfo info = new System.IO.FileInfo(project.FullName);
+        return info.Directory.FullName;
+	}
+    
+    private string GetConfigPath()
+    {
+        EnvDTE.Project project = GetCurrentProject();
+        foreach (EnvDTE.ProjectItem item in project.ProjectItems)
+        {
+            // if it is the app.config file, then open it up
+            if (item.Name.Equals("App.config",StringComparison.InvariantCultureIgnoreCase) || item.Name.Equals("Web.config",StringComparison.InvariantCultureIgnoreCase))
+				return GetProjectPath() + "\\" + item.Name;
+        }
+        return String.Empty;
+    }
+    
+    public string GetDataDirectory(){
+        EnvDTE.Project project=GetCurrentProject();
+        return System.IO.Path.GetDirectoryName(project.FileName)+"\\App_Data\\";
+    }
+
+    public class Table{
+   
+        public List<Column> Columns;
+        public List<FKTable> FKTables;
+        public string Name;
+        public string CleanName;
+        public string ClassName;
+        public string PrimaryKey;
+        public string Schema;
+        public string QueryableName;
+        
+        public bool HasLogicalDelete(){
+            return this.Columns.Any(x=>x.Name.ToLower()=="deleted" || x.Name.ToLower()=="isdeleted");
+        }
+        public Column DeleteColumn{
+            get{
+                Column result=null;
+                if(this.Columns.Any(x=>x.Name.ToLower()=="deleted"))
+                    result=this.Columns.Single(x=>x.Name.ToLower()=="deleted");
+                if(this.Columns.Any(x=>x.Name.ToLower()=="isdeleted"))
+                    result=this.Columns.Single(x=>x.Name.ToLower()=="isdeleted");
+                return result;
+            }
+        }
+        public Column PK{
+            get{
+                return this.Columns.FirstOrDefault(x=>x.IsPK) ?? this.Columns[0];
+            }
+        }
+        public Column Descriptor{
+            get{
+                if(this.Columns.Count==1){
+                    return this.Columns[0];
+                }else{
+                    //get the first string column
+                    Column result=null;
+                    result=this.Columns.FirstOrDefault(x=>x.SysType.ToLower().Trim()=="string");
+                    if(result==null)
+                        result=this.Columns[1];
+                    return result;
+                }
+            }
+        }
+    }
+
+    public class Column{
+        public string Name;
+        public string CleanName;
+        public string SysType;
+        public string DataType;
+        public DbType DbType;
+        public bool AutoIncrement;
+        public bool IsPK;
+        public int MaxLength;
+        public bool IsNullable;
+        public bool IsForeignKey;
+        public bool IsUnsigned;
+    }
+    public class FKTable{
+        public string ThisTable;
+        public string ThisColumn;
+        public string OtherTable;
+        public string OtherColumn;
+        public string OtherClass;
+        public string OtherQueryable;
+    }
+    
+    public class SP{
+        public string Name;
+        public string CleanName;
+        public string ClassName;
+        public List<SPParam> Parameters;
+        public SP(){
+            Parameters=new List<SPParam>();
+        }        
+        public string ArgList{
+            get{
+                StringBuilder sb=new StringBuilder();
+                int loopCount=1;
+                foreach(var par in Parameters){
+                    sb.AppendFormat("{0} {1}", par.SysType,par.CleanName);
+                    if(loopCount<Parameters.Count)
+                        sb.Append(",");
+                    loopCount++;
+                }
+                return sb.ToString();
+            }
+        }
+    }
+    public class SPParam{
+        public string Name;
+        public string CleanName;
+        public string SysType;
+        public string DbType;
+    }
+    
+
+/*
+ * SubSonic - http://subsonicproject.com
+ * 
+ * The contents of this file are subject to the New BSD
+ * License (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.opensource.org/licenses/bsd-license.php
+ * 
+ * Software distributed under the License is distributed on an 
+ * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+*/
+
+    /// <summary>
+    /// Summary for the Inflector class
+    /// </summary>
+    public static class Inflector {
+        private static readonly List<InflectorRule> _plurals = new List<InflectorRule>();
+        private static readonly List<InflectorRule> _singulars = new List<InflectorRule>();
+        private static readonly List<string> _uncountables = new List<string>();
+
+        /// <summary>
+        /// Initializes the <see cref="Inflector"/> class.
+        /// </summary>
+        static Inflector() {
+            AddPluralRule("$", "s");
+            AddPluralRule("s$", "s");
+            AddPluralRule("(ax|test)is$", "$1es");
+            AddPluralRule("(octop|vir)us$", "$1i");
+            AddPluralRule("(alias|status)$", "$1es");
+            AddPluralRule("(bu)s$", "$1ses");
+            AddPluralRule("(buffal|tomat)o$", "$1oes");
+            AddPluralRule("([ti])um$", "$1a");
+            AddPluralRule("sis$", "ses");
+            AddPluralRule("(?:([^f])fe|([lr])f)$", "$1$2ves");
+            AddPluralRule("(hive)$", "$1s");
+            AddPluralRule("([^aeiouy]|qu)y$", "$1ies");
+            AddPluralRule("(x|ch|ss|sh)$", "$1es");
+            AddPluralRule("(matr|vert|ind)ix|ex$", "$1ices");
+            AddPluralRule("([m|l])ouse$", "$1ice");
+            AddPluralRule("^(ox)$", "$1en");
+            AddPluralRule("(quiz)$", "$1zes");
+
+            AddSingularRule("s$", String.Empty);
+            AddSingularRule("ss$", "ss");
+            AddSingularRule("(n)ews$", "$1ews");
+            AddSingularRule("([ti])a$", "$1um");
+            AddSingularRule("((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$", "$1$2sis");
+            AddSingularRule("(^analy)ses$", "$1sis");
+            AddSingularRule("([^f])ves$", "$1fe");
+            AddSingularRule("(hive)s$", "$1");
+            AddSingularRule("(tive)s$", "$1");
+            AddSingularRule("([lr])ves$", "$1f");
+            AddSingularRule("([^aeiouy]|qu)ies$", "$1y");
+            AddSingularRule("(s)eries$", "$1eries");
+            AddSingularRule("(m)ovies$", "$1ovie");
+            AddSingularRule("(x|ch|ss|sh)es$", "$1");
+            AddSingularRule("([m|l])ice$", "$1ouse");
+            AddSingularRule("(bus)es$", "$1");
+            AddSingularRule("(o)es$", "$1");
+            AddSingularRule("(shoe)s$", "$1");
+            AddSingularRule("(cris|ax|test)es$", "$1is");
+            AddSingularRule("(octop|vir)i$", "$1us");
+            AddSingularRule("(alias|status)$", "$1");
+            AddSingularRule("(alias|status)es$", "$1");
+            AddSingularRule("^(ox)en", "$1");
+            AddSingularRule("(vert|ind)ices$", "$1ex");
+            AddSingularRule("(matr)ices$", "$1ix");
+            AddSingularRule("(quiz)zes$", "$1");
+
+            AddIrregularRule("person", "people");
+            AddIrregularRule("man", "men");
+            AddIrregularRule("child", "children");
+            AddIrregularRule("sex", "sexes");
+            AddIrregularRule("tax", "taxes");
+            AddIrregularRule("move", "moves");
+
+            AddUnknownCountRule("equipment");
+            AddUnknownCountRule("information");
+            AddUnknownCountRule("rice");
+            AddUnknownCountRule("money");
+            AddUnknownCountRule("species");
+            AddUnknownCountRule("series");
+            AddUnknownCountRule("fish");
+            AddUnknownCountRule("sheep");
+        }
+
+        /// <summary>
+        /// Adds the irregular rule.
+        /// </summary>
+        /// <param name="singular">The singular.</param>
+        /// <param name="plural">The plural.</param>
+        private static void AddIrregularRule(string singular, string plural) {
+            AddPluralRule(String.Concat("(", singular[0], ")", singular.Substring(1), "$"), String.Concat("$1", plural.Substring(1)));
+            AddSingularRule(String.Concat("(", plural[0], ")", plural.Substring(1), "$"), String.Concat("$1", singular.Substring(1)));
+        }
+
+        /// <summary>
+        /// Adds the unknown count rule.
+        /// </summary>
+        /// <param name="word">The word.</param>
+        private static void AddUnknownCountRule(string word) {
+            _uncountables.Add(word.ToLower());
+        }
+
+        /// <summary>
+        /// Adds the plural rule.
+        /// </summary>
+        /// <param name="rule">The rule.</param>
+        /// <param name="replacement">The replacement.</param>
+        private static void AddPluralRule(string rule, string replacement) {
+            _plurals.Add(new InflectorRule(rule, replacement));
+        }
+
+        /// <summary>
+        /// Adds the singular rule.
+        /// </summary>
+        /// <param name="rule">The rule.</param>
+        /// <param name="replacement">The replacement.</param>
+        private static void AddSingularRule(string rule, string replacement) {
+            _singulars.Add(new InflectorRule(rule, replacement));
+        }
+
+        /// <summary>
+        /// Makes the plural.
+        /// </summary>
+        /// <param name="word">The word.</param>
+        /// <returns></returns>
+        public static string MakePlural(string word) {
+            return ApplyRules(_plurals, word);
+        }
+
+        /// <summary>
+        /// Makes the singular.
+        /// </summary>
+        /// <param name="word">The word.</param>
+        /// <returns></returns>
+        public static string MakeSingular(string word) {
+            return ApplyRules(_singulars, word);
+        }
+
+        /// <summary>
+        /// Applies the rules.
+        /// </summary>
+        /// <param name="rules">The rules.</param>
+        /// <param name="word">The word.</param>
+        /// <returns></returns>
+        private static string ApplyRules(IList<InflectorRule> rules, string word) {
+            string result = word;
+            if (!_uncountables.Contains(word.ToLower())) {
+                for (int i = rules.Count - 1; i >= 0; i--) {
+                    string currentPass = rules[i].Apply(word);
+                    if (currentPass != null) {
+                        result = currentPass;
+                        break;
+                    }
+                }
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Converts the string to title case.
+        /// </summary>
+        /// <param name="word">The word.</param>
+        /// <returns></returns>
+        public static string ToTitleCase(string word) {
+            return Regex.Replace(ToHumanCase(AddUnderscores(word)), @"\b([a-z])",
+                delegate(Match match) { return match.Captures[0].Value.ToUpper(); });
+        }
+
+        /// <summary>
+        /// Converts the string to human case.
+        /// </summary>
+        /// <param name="lowercaseAndUnderscoredWord">The lowercase and underscored word.</param>
+        /// <returns></returns>
+        public static string ToHumanCase(string lowercaseAndUnderscoredWord) {
+            return MakeInitialCaps(Regex.Replace(lowercaseAndUnderscoredWord, @"_", " "));
+        }
+
+
+        /// <summary>
+        /// Adds the underscores.
+        /// </summary>
+        /// <param name="pascalCasedWord">The pascal cased word.</param>
+        /// <returns></returns>
+        public static string AddUnderscores(string pascalCasedWord) {
+            return Regex.Replace(Regex.Replace(Regex.Replace(pascalCasedWord, @"([A-Z]+)([A-Z][a-z])", "$1_$2"), @"([a-z\d])([A-Z])", "$1_$2"), @"[-\s]", "_").ToLower();
+        }
+
+        /// <summary>
+        /// Makes the initial caps.
+        /// </summary>
+        /// <param name="word">The word.</param>
+        /// <returns></returns>
+        public static string MakeInitialCaps(string word) {
+            return String.Concat(word.Substring(0, 1).ToUpper(), word.Substring(1).ToLower());
+        }
+
+        /// <summary>
+        /// Makes the initial lower case.
+        /// </summary>
+        /// <param name="word">The word.</param>
+        /// <returns></returns>
+        public static string MakeInitialLowerCase(string word) {
+            return String.Concat(word.Substring(0, 1).ToLower(), word.Substring(1));
+        }
+
+
+        /// <summary>
+        /// Determine whether the passed string is numeric, by attempting to parse it to a double
+        /// </summary>
+        /// <param name="str">The string to evaluated for numeric conversion</param>
+        /// <returns>
+        /// 	<c>true</c> if the string can be converted to a number; otherwise, <c>false</c>.
+        /// </returns>
+        public static bool IsStringNumeric(string str) {
+            double result;
+            return (double.TryParse(str, NumberStyles.Float, NumberFormatInfo.CurrentInfo, out result));
+        }
+
+        /// <summary>
+        /// Adds the ordinal suffix.
+        /// </summary>
+        /// <param name="number">The number.</param>
+        /// <returns></returns>
+        public static string AddOrdinalSuffix(string number) {
+            if (IsStringNumeric(number)) {
+                int n = int.Parse(number);
+                int nMod100 = n % 100;
+
+                if (nMod100 >= 11 && nMod100 <= 13)
+                    return String.Concat(number, "th");
+
+                switch (n % 10) {
+                    case 1:
+                        return String.Concat(number, "st");
+                    case 2:
+                        return String.Concat(number, "nd");
+                    case 3:
+                        return String.Concat(number, "rd");
+                    default:
+                        return String.Concat(number, "th");
+                }
+            }
+            return number;
+        }
+
+        /// <summary>
+        /// Converts the underscores to dashes.
+        /// </summary>
+        /// <param name="underscoredWord">The underscored word.</param>
+        /// <returns></returns>
+        public static string ConvertUnderscoresToDashes(string underscoredWord) {
+            return underscoredWord.Replace('_', '-');
+        }
+
+
+        #region Nested type: InflectorRule
+
+        /// <summary>
+        /// Summary for the InflectorRule class
+        /// </summary>
+        private class InflectorRule {
+            /// <summary>
+            /// 
+            /// </summary>
+            public readonly Regex regex;
+
+            /// <summary>
+            /// 
+            /// </summary>
+            public readonly string replacement;
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="InflectorRule"/> class.
+            /// </summary>
+            /// <param name="regexPattern">The regex pattern.</param>
+            /// <param name="replacementText">The replacement text.</param>
+            public InflectorRule(string regexPattern, string replacementText) {
+                regex = new Regex(regexPattern, RegexOptions.IgnoreCase);
+                replacement = replacementText;
+            }
+
+            /// <summary>
+            /// Applies the specified word.
+            /// </summary>
+            /// <param name="word">The word.</param>
+            /// <returns></returns>
+            public string Apply(string word) {
+                if (!regex.IsMatch(word))
+                    return null;
+
+                string replace = regex.Replace(word, replacement);
+                if (word == word.ToUpper())
+                    replace = replace.ToUpper();
+
+                return replace;
+            }
+        }
+
+        #endregion
+    }
+
+#>