scripts/core/generate_aliases.pl

   1 #!/usr/bin/perl
   2
   3 ##############
   4 #
   5 #  Name   : generate_aliases
   6 #  Author : Chris Koeritz
   7 #  Rights : Copyright (C) 1996-$now by Author
   8 #
   9 #  Purpose:
  10 #
  11 #    This script generates YETI alias files.  Alias files contain a list of
  12 #  definitions for command aliases that are written in the specified shell
  13 #  dialect (such as bash or perl) and which are additionally tailored for the
  14 #  operating system to be used.
  15 #
  16 ##############
  17 #  This program is free software; you can redistribute it and/or modify it
  18 #  under the terms of the GNU General Public License as published by the Free
  19 #  Software Foundation; either version 2 of the License or (at your option)
  20 #  any later version.  See: "http://www.gruntose.com/Info/GNU/GPL.html" for a
  21 #  version of the License.  Please send any updates to "fred@gruntose.com".
  22 ##############
  23
  24 require "filename_helper.pl";
  25
  26 require "importenv.pl";
  27
  28 # given a possible aliasable filename, this will decide whether to create a perl
  29 # or bash alias for it.  it needs the filename of the possible alias and the
  30 # directory where that file resides.
  31 sub make_alias {
  32   local($file, $dir) = @_;
  33   if ($file =~ /\.[pP][lL]$/) {
  34     local($aliasname) = $file; $aliasname =~ s/\.[Pp][lL]$//;
  35     &make_perl_alias($aliasname, "$dir");
  36   } elsif ($file =~ /\.[sS][hH]$/) {
  37     local($aliasname) = $file; $aliasname =~ s/\.[Ss][Hh]$//;
  38     &make_bash_alias($aliasname, "$dir");
  39   }
  40 }
  41
  42 # makes an alias for a bash script given the alias name.
  43 sub make_bash_alias {
  44   local($aliasname) = shift(@_);
  45   local($full_alias) = $aliasname;
  46   $aliasname =~ s/^.*\/([^\/]*)/\1/;
  47 #print "alias became $aliasname\n";
  48   local($source_dir) = shift(@_);
  49 #print "bash alias is $aliasname, dir is $source_dir\n";
  50   print she "alias $aliasname=\"bash $source_dir/$full_alias.sh\"\n";
  51 }
  52
  53 # makes an alias for a perl script given the alias name.
  54 sub make_perl_alias {
  55   local($aliasname) = shift(@_);
  56   local($full_alias) = $aliasname;
  57   $aliasname =~ s/^.*\/([^\/]*)/\1/;
  58 #print "alias became $aliasname\n";
  59   local($source_dir) = shift(@_);
  60 #print "perl alias is $aliasname, dir is $source_dir\n";
  61   print she "alias $aliasname=\"perl $source_dir/$full_alias.pl\"\n";
  62 }
  63
  64 # given a directory, this returns an array of all the filenames found therein.
  65 sub load_file_names {
  66   local($path) = shift(@_);
  67   opendir(that_dir, $path);
  68   local(@those_files) = sort(readdir(that_dir));
  69   return @those_files;
  70 }
  71
  72 ##############
  73
  74 # The "common.alias" file is used in the generated aliases file as a base
  75 # set of generally useful aliases.  We also add aliases for any script files
  76 # (perl, bash, python, etc) that we find in the feisty meow script hierarchy.
  77 # Any *.alias files found in the $FEISTY_MEOW_GENERATED/custom folder are
  78 # loaded also.
  79 sub rebuild_script_aliases {
  80
  81   if (length($SHELL_DEBUG)) {
  82     print "rebuilding generated aliases file...\n";
  83   }
  84
  85   # create our generated shells directory if it's not already.
  86   if ( ! -d $FEISTY_MEOW_GENERATED ) {
  87     mkdir $FEISTY_MEOW_GENERATED;
  88     if (length($SHELL_DEBUG)) {
  89       print "made FEISTY_MEOW_GENERATED at '$FEISTY_MEOW_GENERATED'\n";
  90     }
  91   }
  92
  93   # test if we can use color in ls...
  94   $test_color=` ls --help 2>&1 | grep -i color `;
  95
  96   # this is an array of files from which to draw alias definitions.
  97   @ALIAS_DEFINITION_FILES = ("$FEISTY_MEOW_SCRIPTS/core/common.alias");
  98
  99   # if custom aliases files exist, add them to the list.
 100   foreach $i (&glob_list("$FEISTY_MEOW_GENERATED/custom/*.alias")) {
 101     if (-f $i) { push(@ALIAS_DEFINITION_FILES, $i); }
 102   }
 103   if (length($SHELL_DEBUG)) {
 104     print "using these alias files:\n";
 105     foreach $i (@ALIAS_DEFINITION_FILES) {
 106       local $base_of_dir = &basename(&dirname($i));
 107       local $basename = &basename($i);
 108       print "  $base_of_dir/$basename\n";
 109     }
 110   }
 111
 112   # write the aliases for sh and bash scripts.
 113
 114   local $GENERATED_ALIAS_FILE = "$FEISTY_MEOW_GENERATED/fmc_core_and_custom_aliases.sh";
 115   if (length($SHELL_DEBUG)) {
 116     print "writing generated aliases in $GENERATED_ALIAS_FILE...\n";
 117   }
 118
 119 #hmmm: perhaps a good place for a function to create the header,
 120 #      given the appropriate comment code.
 121
 122   open GENOUT, ">$GENERATED_ALIAS_FILE" or die "cannot open $GENERATED_ALIAS_FILE";
 123
 124   print GENOUT "##\n";
 125   print GENOUT "## generated file: $GENERATED_ALIAS_FILE\n";
 126   print GENOUT "## please do not edit.\n";
 127   print GENOUT "##\n";
 128
 129   if (length($test_color)) {
 130     print GENOUT "color_add=--color=auto\n";
 131   } else {
 132     print GENOUT "color_add=\n";
 133   }
 134
 135   # plow in the full set of aliases into the file.
 136   foreach $i (@ALIAS_DEFINITION_FILES) {
 137     open CURR_ALIASER, "<$i" or die "cannot open current alias file $i";
 138     foreach $line (<CURR_ALIASER>) {
 139       print GENOUT "$line";
 140     }
 141   }
 142
 143   close GENOUT;
 144
 145   if (length($SHELL_DEBUG)) {
 146     print("done rebuilding generated aliases file.\n");
 147   }
 148 }
 149
 150 ##############
 151
 152 # make sure we know where to store the files we're creating.
 153 if ( ! length("$FEISTY_MEOW_GENERATED") ) {
 154   print "\
 155 The FEISTY_MEOW_GENERATED variable is not defined.  This must point to the location where\n\
 156 the generated scripts are stored.  Perhaps you still need to run\n\
 157 bootstrap_shells.sh and set up some environment variables.  Please see\n\
 158 http://yeticode.org for more details.\n";
 159   exit 1;
 160 #really need to use better exit codes.
 161 }
 162
 163 $FEISTY_MEOW_GENERATED =~ s/\\/\//g;
 164 $FEISTY_MEOW_SCRIPTS =~ s/\\/\//g;
 165 $FEISTY_MEOW_DIR =~ s/\\/\//g;
 166
 167 # create our generated shells directory if it's not already there.
 168 if (! -d $FEISTY_MEOW_GENERATED) {
 169   mkdir $FEISTY_MEOW_GENERATED;
 170 }
 171
 172 ##############
 173
 174 # set the executable bit for yeti binaries for just this current user.
 175 if (-d $BINDIR) {
 176   system("chmod -R u+x \"$BINDIR\"/*");
 177 }
 178
 179 # generate the first set of alias files that are defined in the core
 180 # and custom scripts directories.
 181 &rebuild_script_aliases;
 182
 183 # trash the old versions.
 184 unlink("$FEISTY_MEOW_GENERATED/fmc_aliases_for_scripts.sh");
 185
 186 if (length($SHELL_DEBUG)) {
 187   printf "writing $FEISTY_MEOW_GENERATED/fmc_aliases_for_scripts.sh...\n";
 188 }
 189
 190 # open the alias files to be created.
 191 open(she, ">> $FEISTY_MEOW_GENERATED/fmc_aliases_for_scripts.sh");
 192
 193 #print "os is $OS\n";
 194
 195 # find the list of files in the scripts directory.
 196 #opendir(scripts, "$FEISTY_MEOW_SCRIPTS");
 197 #@shell_files = sort(readdir(scripts));
 198 #print "yeti scripts: @shell_files\n";
 199
 200 @shell_files = &load_file_names("$FEISTY_MEOW_SCRIPTS");
 201
 202 # construct aliases for items in the scripts directory.
 203 foreach $file (@shell_files) {
 204   # test to see what type of item we got.
 205   if ($file =~ '^\.$'
 206       || $file =~ '^\.\.$'
 207       || $file =~ '^.svn$'
 208       || $file =~ '^.git$'
 209       || $file =~ /\/\.$/
 210       || $file =~ /\/\.\.$/
 211       || $file =~ /\/\.svn$/
 212       || $file =~ /\/\.git$/
 213       ) {
 214     # just skip this item; it's a special directory.
 215   } elsif (-d "$FEISTY_MEOW_SCRIPTS/$file") {
 216     # if we see a subdirectory in the scripts folder, we add all the
 217     # scripts in it as aliases.  we recurse only one level.
 218     opendir(subdir, "$FEISTY_MEOW_SCRIPTS/$file");
 219     @subdir_files = sort(readdir(subdir));
 220     foreach $subfile (@subdir_files) {
 221       push(@shell_files, "$file/$subfile");
 222     }
 223   } else {
 224     # if it's a regular file, we'll try to make an alias for it.  the function
 225     # will only fire if the ending is appropriate for the script languages we use.
 226     &make_alias($file, "$FEISTY_MEOW_SCRIPTS");
 227   }
 228 }
 229
 230 # open the source repository's script directory to find scripts in there.
 231 local($build_shell_path) = "$BUILD_TOP/scripts/generator";
 232 @build_shells = &load_file_names("$build_shell_path");
 233 #opendir(build_shells_dir, $build_shell_path);
 234 #@build_shell_files = sort(readdir(build_shells_dir));
 235 #if (scalar(@build_shell_files) > 0) {
 236 #  print "build shell folders: @build_shell_files\n";
 237 #}
 238 foreach $file (@build_shells) {
 239   &make_alias($file, "$build_shell_path");
 240 }
 241
 242 close(she);
 243