tools/respack/respack.cs

   1 //
   2 // Packs a bunch of files as a resource
   3 //
   4 // Used to bundle all the xaml files into the APP.g.resources file
   5 //
   6 // Copyrigh 2008 Novell, Inc.
   7 //
   8 using System;
   9 using System.Reflection;
  10 using System.Collections;
  11 using System.Collections.Generic;
  12 using System.Text.RegularExpressions;
  13 using System.Resources;
  14 using System.IO;
  15 using System.Linq;
  16 using NDesk.Options;
  17
  18 class ResourcePacker {
  19
  20         static void ShowHelp (OptionSet os)
  21         {
  22                 Console.WriteLine ("Usage: respack outputfile [file1[,name] .. [fileN]]");
  23                 Console.WriteLine ();
  24                 os.WriteOptionDescriptions (Console.Out);
  25                 Environment.Exit (0);
  26         }
  27
  28         static bool verbose = false;
  29
  30         public static int Main (string [] args)
  31         {
  32                 bool help = false;
  33                 bool unpack = false;
  34                 string pattern = @"^.+\.xaml?";
  35
  36                 var p = new OptionSet () {
  37                         { "h|?|help", v => help = v != null },
  38                         { "u|unpack", "Extract resources from the supplied assembly.", v => unpack = v != null  },
  39                         { "p|pattern=", "Only extract the resources that match supplied pattern. By default only .xaml files will be extracted.", v => pattern = v  },
  40                         { "v|verbose", v=> verbose = v != null }
  41                 };
  42
  43                 List<string> files = null;
  44                 try {
  45                         files = p.Parse(args);
  46                 } catch (OptionException e){
  47                         Console.WriteLine ("Try `respack --help' for more information.");
  48                         return 1;
  49                 }
  50
  51                 if (help)
  52                         ShowHelp (p);
  53
  54                 if (unpack)
  55                         return Unpack (files [0], pattern);
  56
  57                 if (files == null || files.Count == 0)
  58                         ShowHelp (p);
  59
  60                 return Pack (files);
  61         }
  62
  63         public static int Pack (List<string> files)
  64         {
  65                 ResourceWriter output = null;
  66                 try {
  67                         output = new ResourceWriter (files [0]);
  68                 } catch {
  69                         Console.WriteLine ("Error creating {0} file", files [0]);
  70                 }
  71
  72
  73                 foreach (string f in files.Skip(1)){
  74                         string key;
  75                         string file = f;
  76                         int comma = file.IndexOf (',');
  77                         if (comma != -1) {
  78                                 key = file.Substring (comma + 1);
  79                                 file = file.Substring (0, comma);
  80                         } else {
  81                                 key = Path.GetFileName (file).ToLower ();
  82                         }
  83
  84
  85                         using (FileStream source = File.OpenRead (file)){
  86                                 byte [] buffer = new byte [source.Length];
  87                                 source.Read (buffer, 0, (int) source.Length);
  88
  89                                 // Sadly, we cant just pass byte arrays to resourcewriter, we need
  90                                 // to wrap this on a MemoryStream
  91
  92                                 MemoryStream value = new MemoryStream (buffer);
  93
  94                                 output.AddResource (key.ToLowerInvariant (), value);
  95                         }
  96                 }
  97
  98                 output.Generate ();
  99                 return 0;
 100         }
 101
 102         public static int Unpack (string assembly, string pattern)
 103         {
 104                 Assembly asm = null;
 105                 try {
 106                         asm = Assembly.LoadFile (assembly);
 107                 } catch (Exception e) {
 108                         Console.Error.WriteLine ("Unable to load assembly: {0}.", assembly);
 109                         Console.Error.WriteLine (e);
 110                         return 1;
 111                 }
 112
 113                 string [] resources = asm.GetManifestResourceNames ();
 114
 115                 foreach (string resource in resources) {
 116                         if (verbose)
 117                                 Console.WriteLine ("decompressing '{0}'", resource);
 118
 119                         ResourceReader reader = null;
 120
 121                         try {
 122                                 using (reader = new ResourceReader (asm.GetManifestResourceStream (resource))) {
 123
 124                                         IDictionaryEnumerator id = reader.GetEnumerator ();
 125
 126                                         while (id.MoveNext ()) {
 127                                                 string key = (string) id.Key;
 128                                                 if (!Regex.IsMatch (key, pattern))
 129                                                         continue;
 130
 131                                                 MemoryStream stream = id.Value as MemoryStream;
 132                                                 if (stream == null) {
 133                                                         Console.Error.WriteLine ("Item not stored as a MemoryStream. {0}", key);
 134                                                         continue;
 135                                                 }
 136
 137                                                 byte [] data = new byte [stream.Length];
 138                                                 stream.Read (data, 0, data.Length);
 139
 140                                                 string dir = Path.GetDirectoryName (key);
 141                                                 if (!String.IsNullOrEmpty (dir))
 142                                                         Directory.CreateDirectory (dir);
 143
 144                                                 using (FileStream fs = File.OpenWrite (key)) {
 145                                                         fs.Write (data, 0, data.Length);
 146                                                 }
 147
 148                                         }
 149                                 }
 150                         } catch (Exception e) {
 151                                 Console.WriteLine ("failed to decompress {0}, exception '{1}'.. skipping", resource, e.Message);
 152                         }
 153                 }
 154
 155                 return 0;
 156         }
 157 }