source: branches/replacing_gnuplot/lib/File.cc @ 646

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

Merged trunk changes r608:645 to replacing_gnuplot branch.

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