source: trunk/lib/File.cc @ 693

Last change on this file since 693 was 693, checked in by Jari Häkkinen, 13 years ago

Fixes #339. Change to GPLv3.

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