ui-tree.c

   1 /* ui-tree.c: functions for tree output
   2  *
   3  * Copyright (C) 2006 Lars Hjemli
   4  *
   5  * Licensed under GNU General Public License v2
   6  *   (see COPYING for full license text)
   7  */
   8
   9 #include "cgit.h"
  10
  11 char *curr_rev;
  12 char *match_path;
  13 int header = 0;
  14
  15 static void print_object(const unsigned char *sha1, char *path)
  16 {
  17         enum object_type type;
  18         unsigned char *buf;
  19         unsigned long size, lineno, start, idx;
  20
  21         type = sha1_object_info(sha1, &size);
  22         if (type == OBJ_BAD) {
  23                 cgit_print_error(fmt("Bad object name: %s",
  24                                      sha1_to_hex(sha1)));
  25                 return;
  26         }
  27
  28         buf = read_sha1_file(sha1, &type, &size);
  29         if (!buf) {
  30                 cgit_print_error(fmt("Error reading object %s",
  31                                      sha1_to_hex(sha1)));
  32                 return;
  33         }
  34
  35         html(" blob: <a href='");
  36         html_attr(cgit_pageurl(cgit_query_repo, "blob", fmt("id=%s", sha1_to_hex(sha1))));
  37         htmlf("'>%s</a>",sha1_to_hex(sha1));
  38
  39         html("<table class='blob'>\n");
  40         idx = 0;
  41         start = 0;
  42         lineno = 0;
  43         while(idx < size) {
  44                 if (buf[idx] == '\n') {
  45                         buf[idx] = '\0';
  46                         htmlf("<tr><td class='no'>%d</td><td class='txt'>",
  47                               ++lineno);
  48                         html_txt(buf + start);
  49                         html("</td></tr>\n");
  50                         start = idx + 1;
  51                 }
  52                 idx++;
  53         }
  54         html("</table>\n");
  55 }
  56
  57
  58 static int ls_item(const unsigned char *sha1, const char *base, int baselen,
  59                    const char *pathname, unsigned int mode, int stage)
  60 {
  61         char *name;
  62         char *fullpath;
  63         enum object_type type;
  64         unsigned long size = 0;
  65
  66         name = xstrdup(pathname);
  67         fullpath = fmt("%s%s%s", cgit_query_path ? cgit_query_path : "",
  68                        cgit_query_path ? "/" : "", name);
  69
  70         type = sha1_object_info(sha1, &size);
  71         if (type == OBJ_BAD && !S_ISDIRLNK(mode)) {
  72                 htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>",
  73                       name,
  74                       sha1_to_hex(sha1));
  75                 return 0;
  76         }
  77
  78         html("<tr><td class='ls-mode'>");
  79         html_filemode(mode);
  80         html("</td><td>");
  81         if (S_ISDIRLNK(mode)) {
  82                 htmlf("<a class='ls-mod' href='");
  83                 html_attr(fmt(cgit_repo->module_link,
  84                               name,
  85                               sha1_to_hex(sha1)));
  86                 html("'>");
  87                 html_txt(name);
  88                 html("</a>");
  89         } else if (S_ISDIR(mode)) {
  90                 cgit_tree_link(name, NULL, "ls-dir", cgit_query_head,
  91                                curr_rev, fullpath);
  92         } else {
  93                 cgit_tree_link(name, NULL, "ls-blob", cgit_query_head,
  94                                curr_rev, fullpath);
  95         }
  96         htmlf("</td><td class='ls-size'>%li</td>", size);
  97
  98         html("<td>");
  99         cgit_log_link("log", NULL, "button", cgit_query_head, curr_rev,
 100                       fullpath, 0);
 101         html("</td></tr>\n");
 102         free(name);
 103         return 0;
 104 }
 105
 106 static void ls_head()
 107 {
 108         html("<table class='list'>\n");
 109         html("<tr class='nohover'>");
 110         html("<th class='left'>Mode</th>");
 111         html("<th class='left'>Name</th>");
 112         html("<th class='right'>Size</th>");
 113         html("<th/>");
 114         html("</tr>\n");
 115         header = 1;
 116 }
 117
 118 static void ls_tail()
 119 {
 120         if (!header)
 121                 return;
 122         html("</table>\n");
 123         header = 0;
 124 }
 125
 126 static void ls_tree(const unsigned char *sha1, char *path)
 127 {
 128         struct tree *tree;
 129
 130         tree = parse_tree_indirect(sha1);
 131         if (!tree) {
 132                 cgit_print_error(fmt("Not a tree object: %s",
 133                                      sha1_to_hex(sha1)));
 134                 return;
 135         }
 136
 137         ls_head();
 138         read_tree_recursive(tree, "", 0, 1, NULL, ls_item);
 139         ls_tail();
 140 }
 141
 142
 143 static int walk_tree(const unsigned char *sha1, const char *base, int baselen,
 144                      const char *pathname, unsigned mode, int stage)
 145 {
 146         static int state;
 147         static char buffer[PATH_MAX];
 148         char *url;
 149
 150         if (state == 0) {
 151                 memcpy(buffer, base, baselen);
 152                 strcpy(buffer+baselen, pathname);
 153                 url = cgit_pageurl(cgit_query_repo, "tree",
 154                                    fmt("h=%s&amp;path=%s", curr_rev, buffer));
 155                 html("/");
 156                 cgit_tree_link(xstrdup(pathname), NULL, NULL, cgit_query_head,
 157                                curr_rev, buffer);
 158
 159                 if (strcmp(match_path, buffer))
 160                         return READ_TREE_RECURSIVE;
 161
 162                 if (S_ISDIR(mode)) {
 163                         state = 1;
 164                         ls_head();
 165                         return READ_TREE_RECURSIVE;
 166                 } else {
 167                         print_object(sha1, buffer);
 168                         return 0;
 169                 }
 170         }
 171         ls_item(sha1, base, baselen, pathname, mode, stage);
 172         return 0;
 173 }
 174
 175
 176 /*
 177  * Show a tree or a blob
 178  *   rev:  the commit pointing at the root tree object
 179  *   path: path to tree or blob
 180  */
 181 void cgit_print_tree(const char *rev, char *path)
 182 {
 183         unsigned char sha1[20];
 184         struct commit *commit;
 185         const char *paths[] = {path, NULL};
 186
 187         if (!rev)
 188                 rev = cgit_query_head;
 189
 190         curr_rev = xstrdup(rev);
 191         if (get_sha1(rev, sha1)) {
 192                 cgit_print_error(fmt("Invalid revision name: %s", rev));
 193                 return;
 194         }
 195         commit = lookup_commit_reference(sha1);
 196         if (!commit || parse_commit(commit)) {
 197                 cgit_print_error(fmt("Invalid commit reference: %s", rev));
 198                 return;
 199         }
 200
 201         html("path: <a href='");
 202         html_attr(cgit_pageurl(cgit_query_repo, "tree", fmt("h=%s", rev)));
 203         html("'>root</a>");
 204
 205         if (path == NULL) {
 206                 ls_tree(commit->tree->object.sha1, NULL);
 207                 return;
 208         }
 209
 210         match_path = path;
 211         read_tree_recursive(commit->tree, NULL, 0, 0, paths, walk_tree);
 212         ls_tail();
 213 }