silentbob/plugins/plugin_ruby.cxx

   1 /*
   2  * (c) Oleg Puchinin 2008
   3  * graycardinalster@gmail.com
   4  *
   5  */
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <unistd.h>
  10 #include <fcntl.h>
  11 #include <gclib/gclib.h>
  12 #include <gclib/gclib_c.h>
  13 #include <mod.h>
  14 #include <head.h>
  15 #include <dbg.h>
  16
  17 extern "C" DArray * plugin_init (struct env_t *env);
  18 int ruby_ctags (char * f_name, FILE * of);
  19 FILE * ofile;
  20
  21 void ruby_files ()
  22 {
  23         unlink ("./ruby_files");
  24         sblib_find ("./", "*.rb", "./ruby_files");
  25 }
  26
  27 char ruby_opt (DArray * d_opts, int * pos)
  28 {
  29         if (! d_opts || ! pos)
  30                 return 0;
  31
  32         if (EQ (d_opts->get (*pos), "--ruby")) {
  33                 ENV->language = strdup ("Ruby");
  34                 return 1;
  35         }
  36
  37         if (EQ (d_opts->get (*pos), "--files")) {
  38                 ruby_files ();
  39                 return 1;
  40         }
  41
  42         return 0;
  43 }
  44
  45 char ruby_opt2 (DArray * d_opts, int * pos)
  46 {
  47         return 0;
  48 }
  49
  50 bool ruby_scan_line (const char *S)
  51 {
  52         char * ptr;
  53         if (! S)
  54                 return false;
  55
  56         ptr = strchr  (S, '#');
  57         if (ptr)
  58                 *ptr = '\0';
  59
  60         if  (strstr (S, "class ") ||
  61                         strstr (S, "module ") ||
  62                         strstr (S, "def "))
  63                 return true;
  64
  65         return false;
  66 }
  67
  68 char * ruby_last_word (char * op)
  69 {
  70         char * d_word;
  71         char * S;
  72
  73         S = op;
  74         while (*S) {
  75                 if (*S == '(' || *S == '=' || *S == '[' || *S == '<')
  76                         break;
  77                 S++;
  78         }
  79
  80         while (S[-1] == ' ')
  81                 S--;
  82
  83         *S = 0;
  84         d_word = op;
  85         while (true) {
  86                 S = strchr (d_word, ' ');
  87                 if (S == NULL)
  88                         break;
  89                 d_word = S+1;
  90         }
  91
  92         return d_word;
  93 }
  94
  95 void ruby_tag (char * filename, char * str, int line, FILE * of)
  96 {
  97         char * S;
  98
  99         S = ruby_last_word (str);
 100         if (! S)
 101                 return;
 102
 103         chomp (S);
 104         if (! of)
 105                 printf ("%s\t%s\t%d\n", S, filename, line);
 106         else
 107                 fprintf (of, "%s\t%s\t%d\n", S, filename, line);
 108 }
 109
 110 void ruby_file (char * f_name)
 111 {
 112         FILE * myfile;
 113         char * buf;
 114
 115         if (! f_name)
 116                 return;
 117
 118         myfile = fopen (f_name, "r");
 119         if (! myfile)
 120                 return;
 121
 122         printf ("#   %s\n", f_name);
 123         buf = CNEW (char, 4096);
 124         while (fgets (buf, 4096, myfile)) {
 125                 if (ruby_scan_line (buf))
 126                         printf ("%s", buf);
 127         }
 128
 129         printf ("\n");
 130         fclose (myfile);
 131         DROP (buf);
 132 }
 133
 134 void __ruby_files (char * f_name)
 135 {
 136         unlink (f_name);
 137         sblib_find ("./", "*.rb", f_name);
 138 }
 139
 140
 141 void ruby_lookup ()
 142 {
 143         int i;
 144         DArray * d_array;
 145
 146         __ruby_files (ENV->tmp_files);
 147         d_array = new DArray (32);
 148         d_array->from_file (ENV->tmp_files);
 149         d_array->foreach ((Dfunc_t)chomp);
 150
 151         for (i = 0; i < d_array->get_size (); ++i) {
 152                 if (! d_array->get (i))
 153                         continue;
 154
 155                 ruby_ctags (d_array->get (i), ofile);
 156         }
 157
 158         unlink (ENV->tmp_files);
 159         d_array->foreach (free);
 160         delete d_array;
 161 }
 162
 163 int ruby_ctags (char * f_name, FILE * of)
 164 {
 165         FILE * myfile;
 166         char * buf;
 167         int line = 0;
 168
 169         ofile = of;
 170         if (! f_name) {
 171                 ruby_lookup ();
 172                 return 0;
 173         }
 174
 175         myfile = fopen (f_name, "r");
 176         if (! myfile)
 177                 return -1;
 178
 179         buf = CNEW (char, 4096);
 180         while (fgets (buf, 4096, myfile)) {
 181                 ++line;
 182                 if (ruby_scan_line (buf))
 183                         ruby_tag (f_name, buf, line, of);
 184         }
 185
 186         fclose (myfile);
 187         DROP (buf);
 188
 189         return 0;
 190 }
 191
 192 void ruby_short_info ()
 193 {
 194         printf ("Ruby plugin.");
 195 }
 196
 197 void ruby_long_info ()
 198 {
 199         printf ("Ruby plugin.\n");
 200         printf ("Version: 1.0\n");
 201         printf ("options: --ruby --files --file\n");
 202         printf ("Usage:  bob --ruby --files\n"
 203                 "\tbob ./ruby_files --ruby --make-ctags\n"
 204                 "\tbob <file> --ruby --file\n");
 205 }
 206
 207 DArray * plugin_init (struct env_t *env)
 208 {
 209         DArray * Ret;
 210         mod_t * plug;
 211
 212         Ret = new DArray (1);
 213         plug = CNEW (mod_t, 1);
 214         memset (plug, 0, sizeof (mod_t));
 215
 216         plug->Version = strdup ("1.0");
 217         plug->short_info = ruby_short_info;
 218         plug->long_info = ruby_long_info;
 219         plug->opt = ruby_opt;
 220         plug->opt2 = ruby_opt2;
 221         plug->make_ctags = ruby_ctags;
 222         plug->language = strdup ("Ruby");
 223         plug->file = ruby_file;
 224
 225         ENV->listOptions->add ( "--ruby");
 226         ENV->listOptions->add ("--files");
 227
 228         Ret->add (LPCHAR (plug));
 229         return Ret;
 230 }
 231