source: trunk/lib/File.cc @ 552

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

fixes linetype Copyright

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