build/GSettingsSchemaExtractor.cs

   1 using System;
   2 using System.IO;
   3 using System.Linq;
   4 using System.Text;
   5 using System.Text.RegularExpressions;
   6 using System.Collections.Generic;
   7 using System.Reflection;
   8
   9 public class GSettingsSchemaExtractorProgram
  10 {
  11     private static HashSet<FieldInfo> schema_fields;
  12     private static int schema_count;
  13
  14     public static void Main(string [] args)
  15     {
  16         if (args.Length != 1) {
  17             Console.Error.WriteLine ("Usage: gsettings-schema-extractor.exe /path/to/binaries/");
  18             Environment.Exit (1);
  19         }
  20
  21         var dir = new DirectoryInfo (args [0]);
  22         if (!dir.Exists) {
  23             Console.Error.WriteLine (args [0] + " does not exist");
  24             Environment.Exit (1);
  25         }
  26
  27         Extract (dir);
  28     }
  29
  30     private static void Extract (DirectoryInfo dir)
  31     {
  32         var dot_net_assemblies = dir.EnumerateFiles ()
  33             .Where (f => f.FullName.EndsWith (".dll", true, System.Globalization.CultureInfo.InvariantCulture) ||
  34             f.FullName.EndsWith (".exe", true, System.Globalization.CultureInfo.InvariantCulture));
  35
  36         if (!dot_net_assemblies.Any ()) {
  37             Console.Error.WriteLine ("No binary files found in specified path");
  38             Environment.Exit (1);
  39         }
  40
  41         var types = new List<Type> ();
  42         foreach (var file in dot_net_assemblies) {
  43             Assembly asm = Assembly.LoadFrom (file.FullName);
  44             types.AddRange (asm.GetTypes ());
  45             Console.WriteLine ("Inspecting types in " + file.Name);
  46         }
  47
  48         StringBuilder sbuilder = Extract (types);
  49         if (sbuilder != null) {
  50
  51             string outputFile = Path.Combine (dir.FullName, "org.gnome.banshee.gschema.xml");
  52
  53             using (StreamWriter writer = new StreamWriter (outputFile)) {
  54                 writer.Write (sbuilder.ToString ());
  55             }
  56
  57             Console.WriteLine ("Successfully wrote " + Path.GetFileName (outputFile));
  58         }
  59     }
  60
  61     internal static StringBuilder Extract (IEnumerable<Type> types)
  62     {
  63         Console.WriteLine ("Generating schemas");
  64         schema_count = 0;
  65         schema_fields = new HashSet<FieldInfo> ();
  66
  67         foreach (Type type in types) {
  68             foreach (FieldInfo field in type.GetFields (BindingFlags.Public |
  69                                                         BindingFlags.NonPublic |
  70                                                         BindingFlags.Static)) {
  71                 if (CheckForValidEntry (type, field)) {
  72                     schema_fields.Add (field);
  73                 }
  74             }
  75         }
  76
  77         if (schema_fields.Count > 0) {
  78
  79             var schemaSet = new SchemaSet ();
  80
  81             foreach (FieldInfo field in schema_fields) {
  82                 GSettingsKey.ExtractFromField (schemaSet, field);
  83             }
  84
  85             StringBuilder final = new StringBuilder ();
  86             final.Append ("<schemalist>\n");
  87
  88             foreach (GSettingsSchema schema in schemaSet.Schemas.Values) {
  89                 final.Append (schema.ToString ());
  90             }
  91
  92             final.Append ("</schemalist>\n");
  93
  94             return final;
  95         }
  96         return null;
  97     }
  98
  99     internal class InvalidSchemaException : Exception
 100     {
 101         internal InvalidSchemaException (string msg) : base (msg)
 102         {
 103         }
 104     }
 105
 106     static bool CheckForValidEntry (Type type, FieldInfo field)
 107     {
 108         if (!field.FieldType.IsGenericType || field.Name == "Zero") {
 109             return false;
 110         }
 111
 112         string type_definition = field.FieldType.GetGenericTypeDefinition ().Name;
 113
 114         if (type_definition.StartsWith ("SchemaEntry")) {
 115             Console.WriteLine ("Found SchemaEntry: " + type.FullName + "." + field.Name);
 116
 117             return true;
 118         }
 119
 120         return false;
 121     }
 122
 123     private static string GetStringValueOfFieldNamed (object schemaEntryObject, string fieldName)
 124     {
 125         FieldInfo field = schemaEntryObject.GetType ().GetField (fieldName);
 126         return (string)field.GetValue (schemaEntryObject);
 127     }
 128
 129     private static string GetValueString (Type type, object o)
 130     {
 131         if (type == typeof (bool)) {
 132             return o == null ? null : o.ToString ().ToLower ();
 133         }
 134
 135         if (type == typeof (string)) {
 136             string value = o == null ? String.Empty : o.ToString ();
 137             return String.Format ("'{0}'", value);
 138         }
 139
 140         if (type == typeof (int) || type == typeof (double)) {
 141             return o == null ? null : o.ToString ();
 142         }
 143
 144         throw new Exception (String.Format ("Unsupported type '{0}'", type));
 145     }
 146
 147     private static string GetGcType (Type type)
 148     {
 149         if (type == null) {
 150             throw new ArgumentNullException ("type");
 151         }
 152
 153         // gctypes to return taken from http://developer.gnome.org/glib/unstable/glib-GVariant.html#GVariantClass
 154
 155         if (type == typeof (bool)) {
 156             return "b";
 157         }
 158
 159         if (type == typeof (int)) {
 160             return "i";
 161         }
 162
 163         if (type == typeof (double)) {
 164             return "d";
 165         }
 166
 167         if (type == typeof (string)) {
 168             return "s";
 169         }
 170
 171         throw new Exception (String.Format ("Unsupported type '{0}'", type));
 172     }
 173
 174     internal struct GSettingsSchema
 175     {
 176         internal string Id { get; private set; }
 177         internal string Path { get { return Id.Replace ("org.gnome.", "/apps/").Replace (".", "/") + "/"; } }
 178
 179         internal HashSet<GSettingsKey> Keys { get; private set; }
 180
 181         internal GSettingsSchema (string id) : this ()
 182         {
 183             Id = id;
 184             Keys = new HashSet<GSettingsKey> ();
 185         }
 186
 187         public override string ToString ()
 188         {
 189             string result = String.Empty;
 190             result += String.Format ("  <schema id=\"{0}\" path=\"{1}\" gettext-domain=\"banshee\">\n", Id, Path);
 191             foreach (var key in Keys) {
 192                 result += key.ToString ();
 193             }
 194             result += ("  </schema>\n");
 195             return result;
 196         }
 197
 198     }
 199
 200     internal struct GSettingsKey
 201     {
 202         internal GSettingsSchema ParentSchema { get; private set; }
 203         internal string Default { get; private set; }
 204         internal string KeyName { get; private set; }
 205         internal string KeyType { get; private set; }
 206         internal string Summary { get; private set; }
 207         internal string Description { get; private set; }
 208
 209         internal static GSettingsKey ExtractFromField (SchemaSet schemaSet, FieldInfo field)
 210         {
 211             if (field == null) {
 212                 throw new ArgumentNullException ("field");
 213             }
 214
 215             object schema = field.GetValue (null);
 216             if (schema == null) {
 217                 throw new InvalidSchemaException (String.Format (
 218                     "Schema could not be retrieved from field {0} in type {1}",
 219                     field.Name, field.DeclaringType.FullName));
 220             }
 221
 222             var default_value_field = schema.GetType ().GetField ("DefaultValue");
 223             var default_value = default_value_field.GetValue (schema);
 224
 225             var default_value_type = default_value_field.FieldType;
 226             var namespce = GetStringValueOfFieldNamed (schema, "Namespace");
 227             var key = GetStringValueOfFieldNamed (schema, "Key");
 228             var short_description = GetStringValueOfFieldNamed (schema, "ShortDescription");
 229             var long_description = GetStringValueOfFieldNamed (schema, "LongDescription");
 230
 231             return new GSettingsKey (schemaSet, default_value, default_value_type, namespce, key, short_description, long_description);
 232         }
 233
 234         private GSettingsKey (SchemaSet schemaSet, object defaultValue, Type defaultValueType,
 235                               string namespce, string key,
 236                               string short_desc, string long_desc) : this ()
 237         {
 238             ParentSchema = schemaSet.RetrieveOrCreate (namespce);
 239
 240             Default = GetDefault (defaultValue, defaultValueType);
 241             KeyName = key.Replace ("_", "-");
 242             KeyType = GetTypeAttrib (defaultValue, defaultValueType);
 243             Summary = short_desc;
 244             Description = long_desc;
 245
 246             ParentSchema.Keys.Add (this);
 247         }
 248
 249         public override string ToString ()
 250         {
 251             string result = String.Empty;
 252             result += String.Format ("    <key name=\"{0}\" type=\"{1}\">\n", KeyName, KeyType);
 253             result += String.Format ("      <default>{0}</default>\n", Default);
 254             result += String.Format ("      <summary>{0}</summary>\n", Summary);
 255             result += String.Format ("      <description>{0}</description>\n", Description);
 256             result +=               ("    </key>\n");
 257             return result;
 258         }
 259     }
 260
 261     internal class SchemaSet
 262     {
 263         internal SchemaSet ()
 264         {
 265             Schemas = new Dictionary<string, GSettingsSchema> ();
 266         }
 267
 268         internal Dictionary<string, GSettingsSchema> Schemas { get; private set; }
 269
 270         private static string NamespaceToId (string namespce)
 271         {
 272             return "org.gnome.banshee." + CamelCaseToUnderScoreLowerCase (namespce);
 273         }
 274
 275         internal GSettingsSchema RetrieveOrCreate (string namespce)
 276         {
 277             string id = NamespaceToId (namespce);
 278             GSettingsSchema schema;
 279             if (!Schemas.TryGetValue (id, out schema)) {
 280                 schema = new GSettingsSchema (id);
 281                 Schemas [id] = schema;
 282             }
 283             return schema;
 284         }
 285     }
 286
 287     internal static string GetTypeAttrib (object defaultValue, Type defaultValueType)
 288     {
 289         var i_enumerable_interface = defaultValueType.GetInterfaces ()
 290             .Where (i => i.IsGenericType && i.GetGenericTypeDefinition () == typeof (IEnumerable<>)).FirstOrDefault ();
 291         bool list = defaultValueType.IsArray;
 292         if (list) {
 293             var inner_type = i_enumerable_interface.GetGenericArguments () [0];
 294             return "a" + GetGcType (inner_type);
 295         }
 296         return GetGcType (defaultValueType);
 297     }
 298
 299     internal static string GetDefault (object defaultValue, Type defaultValueType)
 300     {
 301         bool list = defaultValueType.IsArray;
 302
 303         string str_val = null;
 304
 305         if (list) {
 306             if (defaultValue == null || ((object[])defaultValue).Length == 0) {
 307                 str_val = "[]";
 308             } else {
 309                 var type = Type.GetTypeArray ((object [])defaultValue) [0];
 310                 str_val = "[";
 311                 object [] arr = (object [])defaultValue;
 312                 for (int i = 0; i < arr.Length; i++) {
 313                     str_val += GetValueString (type, arr [i]).Replace (",", "\\,");
 314                     if (i < arr.Length - 1) {
 315                         str_val += ",";
 316                     }
 317                 }
 318                 str_val += "]";
 319             }
 320         } else {
 321             str_val = GetValueString (defaultValueType, defaultValue);
 322         }
 323         return str_val;
 324     }
 325
 326     private static string CamelCaseToUnderScoreLowerCase (string s)
 327     {
 328         string undercase = String.Empty;
 329         string [] tokens = Regex.Split (s, "([A-Z]{1}[a-z]+)");
 330
 331         for(int i = 0; i < tokens.Length; i++) {
 332             if (tokens [i] == String.Empty) {
 333                 continue;
 334             }
 335
 336             undercase += tokens [i].ToLower();
 337             if (i < tokens.Length - 2) {
 338                 undercase += "_";
 339             }
 340         }
 341
 342         return undercase;
 343     }
 344 }
 345