source: trunk/lib/File.cc @ 663

Last change on this file since 663 was 663, checked in by Peter Johansson, 13 years ago

reverting previous commit

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 11.9 KB
Line 
1// $Id: File.cc 663 2008-06-13 00:08:32Z peter $
2
3/*
4  Copyright (C) 2005, 2006, 2007 Jari Häkkinen, Peter Johansson
5
6  This file is part of svndigest, http://trac.thep.lu.se/svndigest
7
8  svndigest is free software; you can redistribute it and/or modify it
9  under the terms of the GNU General Public License as published by
10  the Free Software Foundation; either version 2 of the License, or
11  (at your option) any later version.
12
13  svndigest is distributed in the hope that it will be useful, but
14  WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  General Public License for more details.
17
18  You should have received a copy of the GNU General Public License
19  along with this program; if not, write to the Free Software
20  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
21  02111-1307, USA.
22*/
23
24#include "File.h"
25
26#include "Alias.h"
27#include "Configuration.h"
28#include "Date.h"
29#include "GnuplotFE.h"
30#include "html_utility.h"
31#include "HtmlStream.h"
32#include "Stats.h"
33#include "SVNblame.h"
34#include "SVNlog.h"
35
36#include <algorithm>
37#include <cassert>
38#include <cstdio>
39#include <ctime>
40#include <fstream>
41#include <iostream>
42#include <map>
43#include <stdexcept>
44#include <string>
45#include <sys/stat.h>
46
47namespace theplu{
48namespace svndigest{
49
50
51  File::File(const unsigned int level, const std::string& path, 
52             const std::string& output) 
53    : Node(level,path,output) 
54  {
55    output_dir_=output;
56    if (!output_dir_.empty())
57      output_dir_+='/';
58  }
59
60
61  std::map<int, std::set<Alias> >
62  File::copyright_map(std::map<std::string, Alias>& alias,
63                      const std::map<int, svn_revnum_t>& year2rev) const
64  {
65    using namespace std;
66    map<int, set<Alias> > year_authors;
67    const Stats& stats = stats_["add"];
68
69    // loop over all years
70    for (std::map<int, svn_revnum_t>::const_iterator rev_iter=year2rev.begin();
71         rev_iter!=year2rev.end(); ++rev_iter) {
72
73      svn_revnum_t last_rev_this_year = rev_iter->second;
74      svn_revnum_t last_rev_last_year = 0;
75      if (rev_iter != year2rev.begin()) {
76        last_rev_last_year = (--rev_iter)->second;
77        ++rev_iter;
78      }
79      // loop over authors
80      for (std::set<std::string>::const_iterator a_iter=stats.authors().begin();
81           a_iter!=stats.authors().end(); ++a_iter) {
82
83        // check if anything has been added since last year
84        if ( (stats(LineTypeParser::code, *a_iter, last_rev_this_year) >
85              stats(LineTypeParser::code, *a_iter, last_rev_last_year)) || 
86             (stats(LineTypeParser::comment, *a_iter, last_rev_this_year) >
87              stats(LineTypeParser::comment, *a_iter, last_rev_last_year)) ) {
88       
89       
90          // find username in map of aliases
91          std::map<string,Alias>::iterator name(alias.lower_bound(*a_iter));
92         
93          // if alias exist insert alias
94          if (name != alias.end() && name->first==*a_iter)
95            year_authors[rev_iter->first].insert(name->second);
96          else {
97            // else insert user name
98            Alias a(*a_iter,alias.size());
99            year_authors[rev_iter->first].insert(a);
100            std::cerr << "svndigest: warning: no copyright alias found for `" 
101                      << *a_iter << "'\n";
102            // insert alias to avoid multiple warnings.
103            alias.insert(name, std::make_pair(*a_iter, a));
104          }
105        }
106      }
107    }
108    return year_authors;
109  }
110
111
112  std::string
113  File::copyright_block(const std::map<int, std::set<Alias> >& year_authors,
114                        const std::string& prefix) const
115  {
116    using namespace std;
117    stringstream ss;
118    for (map<int, set<Alias> >::const_iterator i(year_authors.begin());
119         i!=year_authors.end();) {
120      ss << prefix << "Copyright (C) "
121          << 1900+i->first;
122      map<int, set<Alias> >::const_iterator j = i;
123      assert(i!=year_authors.end());
124      while (++j!=year_authors.end() && 
125             i->second == j->second){
126        ss << ", " << 1900+(j->first);
127      }
128      // printing authors
129      std::vector<Alias> vec_alias;
130      back_insert_iterator<std::vector<Alias> > ii(vec_alias);
131      std::copy(i->second.begin(), i->second.end(), ii);
132      // sort with respect to id
133      std::sort(vec_alias.begin(), vec_alias.end(), IdCompare());
134      for (std::vector<Alias>::iterator a=vec_alias.begin();
135           a!=vec_alias.end(); ++a){
136        if (a!=vec_alias.begin())
137          ss << ",";
138        ss << " " << a->name();
139      }
140      ss << "\n";
141      i = j;
142    }
143    return ss.str();
144  }
145
146  bool File::detect_copyright(std::string& block, size_t& start_at_line,
147                              size_t& end_at_line, std::string& prefix) const
148  {
149    using namespace std;
150    LineTypeParser parser(path());
151    std::ifstream is(path().c_str());
152    std::string line;
153    while (std::getline(is, line)) 
154      parser.parse(line);
155    if (!parser.copyright_found())
156      return false;
157    block = parser.block();
158    start_at_line = parser.start_line();
159    end_at_line = parser.end_line();
160    prefix = parser.prefix();
161    return true;
162  }
163
164
165  std::string File::href(void) const
166  { 
167    return name()+".html"; 
168  }
169
170
171  SVNlog File::log_core(void) const
172  {
173    return SVNlog(path());
174  }
175
176
177  std::string File::node_type(void) const
178  {
179    return std::string("file");
180  }
181
182
183  std::string File::output_path(void) const
184  {
185    return output_dir()+name()+".html";
186  }
187
188
189  const StatsCollection& File::parse(bool verbose, bool ignore)
190  {
191    if (verbose)
192      std::cout << "Parsing " << path_ << std::endl; 
193    stats_.reset();
194    std::string cache_dir = directory_name(path()) + std::string(".svndigest/"); 
195    std::string cache_file = cache_dir + name()+std::string(".svndigest-cache");
196    if (!ignore && node_exist(cache_file)){
197      std::ifstream is(cache_file.c_str());
198      if (stats_.load_cache(is)){
199        return stats_;
200      }
201      is.close();
202    }
203    else 
204      stats_.parse(path_);
205    if (!node_exist(cache_dir))
206      mkdir(cache_dir);
207    std::ofstream os(cache_file.c_str());
208    stats_.print(os);
209    os.close();
210    return stats_;
211  }
212
213
214  void File::print_blame(std::ofstream& os) const
215  {
216    os << "<br /><h3>Blame Information</h3>";
217    os << "<table class=\"blame\">\n";
218    os << "<thead>\n";
219    os << "<tr>\n";
220    os << "<th class=\"rev\">Rev</th>\n";
221    os << "<th class=\"date\">Date</th>\n";
222    os << "<th class=\"author\">Author</th>\n";
223    os << "<th class=\"line\">Line</th>\n";
224    os << "<th></th>\n";
225    os << "</tr>\n</thead>\n";
226    os << "<tbody>\n";
227    HtmlStream hs(os);
228    SVNblame blame(path_);
229    LineTypeParser parser(path_);
230    while (blame.valid()) {
231      parser.parse(blame.line());
232      blame.next_line();
233    }
234    blame.reset();
235
236    std::vector<LineTypeParser::line_type>::const_iterator
237      line_type(parser.type().begin());
238    int last=0;
239    int first=0;
240    bool using_dates=true;
241    if (GnuplotFE::instance()->dates().empty()){
242      using_dates=false;
243      last = stats_["classic"].revision();
244    }
245    else {
246      last = Date(GnuplotFE::instance()->dates().back()).seconds();
247      // earliest date corresponds either to revision 0 or revision 1
248      first = std::min(Date(GnuplotFE::instance()->dates()[0]).seconds(),
249                       Date(GnuplotFE::instance()->dates()[1]).seconds());
250    }
251    // color is calculated linearly on time, c = kt + m
252    // brightest color (for oldest rev in log) is set to 192.
253    double k = 192.0/(first-last);
254    double m = -last*k; 
255    while (blame.valid()) {
256      std::string color;
257      if (using_dates)
258        color = hex(static_cast<int>(k*Date(blame.date()).seconds()+m),2);
259      else
260        color = hex(static_cast<int>(k*blame.revision()+m),2);
261      os << "<tr>\n<td class=\"rev\">";
262      std::stringstream color_ss;
263      color_ss << "#" << color << color << color; 
264      os << "<font color=\"" << color_ss.str() << "\">"
265         << trac_revision(blame.revision(), color_ss.str())
266         << "</font></td>\n<td class=\"date\"><font color=\"#" << color
267         << color << color << "\">" ;
268      hs << Date(blame.date())("%d %b %y");
269      os << "</font></td>\n<td class=\"author\">";
270      hs << blame.author();
271      os << "</td>\n<td class=\"";
272      assert(line_type!=parser.type().end());
273      if (*line_type==LineTypeParser::other)
274        os << "line-other";
275      else if (*line_type==LineTypeParser::comment || 
276               *line_type==LineTypeParser::copyright)       
277        os << "line-comment";
278      else if (*line_type==LineTypeParser::code)
279        os << "line-code";
280      else {
281        std::string msg="File::print_blame(): unexpected line type found";
282        throw std::runtime_error(msg);
283      }
284      os << "\">" << blame.line_no()+1
285         << "</td>\n<td>";
286      hs << blame.line();
287      os << "</td>\n</tr>\n";
288      blame.next_line();
289      ++line_type;
290    }
291    os << "</tbody>\n";
292    os << "</table>\n";
293  }
294
295
296  void File::print_copyright(std::map<std::string, Alias>& alias, 
297                             bool verbose,
298                             const std::map<int,svn_revnum_t>& y2rev) const 
299  {
300    if (ignore())
301      return;
302
303    std::string old_block;
304    size_t start_line=0;
305    size_t end_line=0;
306    std::string prefix;
307    if (!detect_copyright(old_block, start_line, end_line, prefix)){
308      if (Configuration::instance().missing_copyright_warning())
309        std::cerr << "svndigest: warning: no copyright statement found in `" 
310                  << path_ << "'\n";
311      return;
312    }
313    std::map<int, std::set<Alias> > map=copyright_map(alias, y2rev);
314    std::string new_block = copyright_block(map, prefix);
315    if (old_block==new_block)
316      return;
317    if (verbose)
318      std::cout << "Updating copyright in " << path_ << std::endl; 
319    update_copyright(new_block, start_line, end_line);
320  }
321
322
323  void File::print_core(const bool verbose) const 
324  {
325  }
326
327
328  void File::print_core(const std::string& stats_type, 
329                        const std::string& user, const std::string& line_type,
330                        const SVNlog& log) const 
331  {
332    std::string lpath = local_path();
333    if (lpath.empty())
334      lpath = "index";
335    std::string outpath = stats_type+"/"+user+"/"+line_type+"/"+lpath;
336    std::string imagefile = stats_type+"/"+"images/"+line_type+"/"+
337      lpath+".png";
338    std::string html_name(outpath + ".html");
339    std::ofstream os(html_name.c_str());
340    print_header(os, name(), level_+3, user, line_type, lpath+".html",
341                 stats_type);
342    path_anchor(os);
343    os << "<p class=\"plot\">\n<img src='"; 
344    for (size_t i=0; i<level_; ++i)
345      os << "../";
346    os << "../../../";
347    if (user=="all")
348      os << stats_[stats_type].plot(imagefile,line_type);
349    else
350      os << imagefile;
351    os << "' alt='[plot]' />\n</p>";
352
353    print_author_summary(os, stats_[stats_type], line_type, log);
354    os << "\n";
355
356    print_blame(os);
357
358    print_footer(os);
359    os.close(); 
360  }
361
362  void File::update_copyright(const std::string& new_block,
363                              size_t start_at_line, size_t end_at_line) const
364  {
365    // Code copied from Gnuplot -r70
366    char tmpname[]="/tmp/svndigestXXXXXX";
367    int fd=mkstemp(tmpname);  // mkstemp return a file descriptor
368    if (fd == -1)
369      throw std::runtime_error(std::string("Failed to get unique filename: ") +
370                               tmpname);
371    // Jari would like to do something like 'std::ofstream tmp(fd);'
372    // but has to settle for (which is stupid since the file is
373    // already open for writing.
374    std::ofstream tmp(tmpname);
375
376    using namespace std;
377    ifstream is(path().c_str());
378    assert(is.good());
379    string line;
380    // Copy lines before block
381    for (size_t i=1; i<start_at_line; ++i){
382      assert(is.good());
383      getline(is, line);
384      tmp << line << "\n";
385    }
386    // Printing copyright statement
387    tmp << new_block;
388    // Ignore old block lines
389    for (size_t i=start_at_line; i<end_at_line; ++i){
390      assert(is.good());
391      getline(is, line);
392    }
393    // Copy lines after block
394    while(is.good()) {
395      char ch=is.get();
396      if (is.good())
397        tmp.put(ch);
398    }
399
400    is.close();
401    tmp.close();
402    close(fd);
403    // get file permission
404    struct stat nodestat;
405    stat(path().c_str(),&nodestat);
406   
407    // finally copy temporary file to replace original file, and
408    // remove the temporary file
409    try {
410      copy_file(tmpname, path());
411    }
412    catch (std::runtime_error e) {
413      // catch exception, cleanup, and rethrow
414      std::cerr << "File::print_copyright: Exception caught, "
415                << "removing temporary file " << tmpname << std::endl;
416      if (unlink(tmpname))
417        throw runtime_error(std::string("File::print_copyright: ") +
418                            "failed to unlink temporary file" + tmpname);
419      throw;
420    }
421    if (unlink(tmpname))
422      throw runtime_error(std::string("File::print_copyright: ") +
423                          "failed to unlink temporary file" + tmpname);
424
425    chmod(path().c_str(), nodestat.st_mode);
426  }
427
428
429}} // end of namespace svndigest and namespace theplu
Note: See TracBrowser for help on using the repository browser.