Experiments/Attic/Generator/Castle.ActiveRecord.Generator.Components/NamingService.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.ActiveRecord.Generator.Components
  16 {
  17         using System;
  18         using System.Text.RegularExpressions;
  19
  20         using Castle.ActiveRecord.Generator.Components.Utils;
  21
  22
  23         public class NamingService : INamingService
  24         {
  25                 private Pair[] pluralRules = new Pair[]
  26                 {
  27                                 new Pair("(x|ch|ss|sh)$", "$1es"),
  28                                 new Pair("series$", "$1series"),
  29                                 new Pair("([^aeiouy]|qu)y$", "$1ies"),
  30                                 new Pair("(?:([^f])fe|([lr])f)$", "$1$2ves"),
  31                                 new Pair("sis$", "ses"),
  32                                 new Pair("([ti])um$", "$1a"),
  33                                 new Pair("Person$", "People"),
  34                                 new Pair("Man$", "Men"),
  35                                 new Pair("Child$", "Children"),
  36                                 new Pair("s$", "s"),
  37                                 new Pair("$", "s")
  38                 };
  39
  40                 private Pair[] singularRules = new Pair[]
  41                 {
  42                         new Pair("(x|ch|ss)es$", @"$1"),
  43                         new Pair("Movies$", "Movie"),
  44                         new Pair("([^aeiouy]|qu)ies$", "$1y"),
  45                         new Pair("([lr])ves$", @"$1f"),
  46                         new Pair("([^f])ves$", @"$1fe"),
  47                         new Pair("(analy|ba|diagno|parenthe|progno|synop|the)ses$", @"$1sis"),
  48                         new Pair("([ti])a$", @"$1um"),
  49                         new Pair("People$", @"Person"),
  50                         new Pair("Men$", @"Man"),
  51                         new Pair("Status$", @"Status"),
  52                         new Pair("Children$", @"Child"),
  53                         new Pair("s$", @"")
  54                 };
  55
  56                 public String CreateRelationName(String tableName)
  57                 {
  58                         MatchEvaluator UpCaser = new MatchEvaluator(UpCaserDef);
  59
  60                         tableName = Regex.Replace(tableName, "(tb_|_)", "");
  61                         tableName = Regex.Replace(tableName, "^[a-z]", UpCaser);
  62
  63                         return Pluralize(tableName);
  64                 }
  65
  66                 public String CreateClassName(String tableName)
  67                 {
  68                         MatchEvaluator UpCaser = new MatchEvaluator(UpCaserDef);
  69
  70                         tableName = Regex.Replace(tableName, "(tb_|_)", "");
  71                         tableName = Regex.Replace(tableName, "^[a-z]", UpCaser);
  72
  73                         return Singularize(tableName);
  74                 }
  75
  76                 public String CreatePropertyName(String columnName)
  77                 {
  78                         MatchEvaluator UpCaser = new MatchEvaluator(UpCaserDef);
  79
  80                         columnName = Regex.Replace(columnName, "([a-z])_([a-z])", UpCaser);
  81                         columnName = Regex.Replace(columnName, "(tb_|_)", "");
  82                         columnName = Regex.Replace(columnName, "^[a-z]", UpCaser);
  83                         columnName = Regex.Replace(columnName, "[^1-9a-zA-Z]", "");
  84
  85                         return columnName;
  86                 }
  87
  88                 public String CreateFieldName(String columnName)
  89                 {
  90                         MatchEvaluator UpCaser = new MatchEvaluator(UpCaserDef);
  91                         MatchEvaluator DownCaser = new MatchEvaluator(DownCaserDef);
  92
  93                         columnName = Regex.Replace(columnName, "([a-z])_([a-z])", UpCaser);
  94                         columnName = Regex.Replace(columnName, "(tb_|_)", "");
  95                         columnName = Regex.Replace(columnName, "^[A-Z]",  DownCaser);
  96                         columnName = Regex.Replace(columnName, "[^1-9a-zA-Z]", "");
  97
  98                         return String.Format("_{0}", columnName);
  99                 }
 100
 101                 private String UpCaserDef(Match match)
 102                 {
 103                         if (match.Value.Length == 1)
 104                         {
 105                                 return match.Value.ToUpper();
 106                         }
 107
 108                         return String.Format( "{0}_{1}", match.Value[0], match.Value.ToUpper()[2] );
 109                 }
 110
 111                 private String DownCaserDef(Match match)
 112                 {
 113                         return match.Value.ToLower();
 114                 }
 115
 116                 private String Singularize(String name)
 117                 {
 118                         foreach(Pair pair in singularRules)
 119                         {
 120                                 String result = Regex.Replace(name, pair.First, pair.Second);
 121                                 if (!result.Equals(name))
 122                                 {
 123                                         return result;
 124                                 }
 125                         }
 126
 127                         return name;
 128                 }
 129
 130                 private String Pluralize(String name)
 131                 {
 132                         String result = name;
 133
 134                         foreach(Pair pair in pluralRules)
 135                         {
 136                                 result = Regex.Replace(name, pair.First, pair.Second, RegexOptions.IgnoreCase|RegexOptions.Singleline);
 137                                 if (!result.Equals(name))
 138                                 {
 139                                         break;
 140                                 }
 141                         }
 142
 143                         if (result.EndsWith("ss"))
 144                         {
 145                                 result = result.Substring(0, result.Length - 1);
 146                         }
 147
 148                         return result;
 149                 }
 150         }
 151 }