source: trunk/lib/File.cc @ 232

// $Id: File.cc 232 2007-03-25 22:00:13Z peter $

/*
  Copyright (C) 2005, 2006 Jari Häkkinen, Peter Johansson
  Copyright (C) 2007 Peter Johansson

  This file is part of svndigest, http://lev.thep.lu.se/trac/svndigest

  svndigest is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  svndigest is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "File.h"
#include "html_utility.h"
#include "Stats.h"
#include "SVN.h"

#include <cassert>
#include <ctime>
#include <fstream>
#include <iostream>
#include <map>
#include <string>

namespace theplu{
namespace svndigest{


  std::string File::href(void) const
  { 
    return name()+".html"; 
  }


  const std::string File::node_type(void) const
  {
    return std::string("file");
  }


  const Stats& File::parse(const bool verbose)
  {
    if (verbose)
      std::cout << "Parsing " << path_ << std::endl; 
    stats_.reset();
    stats_.parse(path_);
    return stats_;
  }


  void File::print(const std::string& user, const std::string& line_type) const 
  {
    std::string outpath = user+"/"+line_type+"/"+local_path();
    std::string html_name(outpath + ".html");
    std::ofstream os(html_name.c_str());
    print_header(os, name(), level_+2, line_type, local_path()+".html");
    path_anchor(os);
    os << "<p align=center>\n<img src='" 
       << file_name(stats_.plot(outpath+".png",local_path(),line_type))
       << "' alt='[plot]' border=0>\n</p>";

    os << "<table class=\"listings\">\n";
    os << "<thead>";
    os << "<tr>\n";
    os << "<th>Author</th>\n";
    os << "<th>Lines</th>\n";
    os << "<th>Code</th>\n";
    os << "<th>Comments</th>\n";
    os << "</tr>\n</thead>\n";
    os << "<tbody>";

    bool dark=false;
    os << "<tr class=\"light\">\n";
    os << "<td class=\"directory\" colspan=\"5\">";
    anchor(os, "index.html", "../");
    os << "</td>\n</tr>\n";
    dark=!dark;
    
    // print authors
    for (std::set<std::string>::const_iterator i=stats_.authors().begin();
         i!=stats_.authors().end(); ++i){
      if (dark)
        os << "<tr class=\"dark\"><td>" << *i 
           << "</td><td>" << stats_.lines(*i)
           << "</td><td>" << stats_.code(*i)
           << "</td><td>" << stats_.comments(*i)
           << "</td></tr>\n";
      else
        os << "<tr class=\"light\"><td>" << *i 
           << "</td><td>" << stats_.lines(*i)
           << "</td><td>" << stats_.code(*i)
           << "</td><td>" << stats_.comments(*i)
           << "</td></tr>\n";
      dark=!dark;
    }
    if (dark)
      os << "<tr class=\"dark\">\n";
    else
      os << "<tr class=\"light\">\n";
    os << "<td>Total</td>\n";
    os << "<td>" << stats_.lines() << "</td>\n";
    os << "<td>" << stats_.code() << "</td>\n";
    os << "<td>" << stats_.comments() << "</td>\n";
    os << "</tr>\n";
    os << "</table>\n";
    os << "</p>\n";

    print_footer(os);
    os.close(); 
  }


  void File::print(const bool verbose) const 
  {
    // no output page for binary files
    if (ignore())
      return;
    if (verbose)
      std::cout << "Printing output for " << path_ << std::endl;
    print("all", "total");
    print("all", "code");
    print("all", "comments");
    print("all", "empty");

    for (std::set<std::string>::const_iterator i = stats_.authors().begin();
         i!=stats_.authors().end(); ++i) {
      print(*i, "total");
      print(*i, "code");
      print(*i, "comments");
      print(*i, "empty");
    }

  }


  void File::print_blame(std::ofstream& os, const std::string line_type) const
  {
    os << "<table class=\"blame\">\n";

    os << "</table>\n";
  }


  void File::print_copyright
  (const std::vector<std::string>& dates,
   const std::vector<std::string>& authors,
   std::map<std::string, std::string>& alias) const
  {
    if (ignore())
      return;
    assert(dates.size()==authors.size());
    using namespace std;
    SVN* svn=SVN::instance();
    vector<size_t> rev=svn->revisions(path());

    typedef map<int, set<string> > Container;
    Container copyright;
    for (vector<size_t>::iterator i=rev.begin(); i!=rev.end(); ++i) {
      assert(*i<dates.size());
      time_t sec = str2time(dates[*i]);
      tm* timeinfo = gmtime(&sec);

      // find username in map of aliases
      map<string, string>::iterator name = alias.lower_bound(authors[*i]);
      // if alias exist insert alias
      if (name != alias.end() && name->first==authors[*i])
        copyright[timeinfo->tm_year].insert(name->second);
      else {
        // else insert user name
        copyright[timeinfo->tm_year].insert(authors[*i]);
        std::cerr << "Warning: no alias found for `" << authors[*i] << "`\n";
        // insert alias to avoid multiple warnings.
        alias.insert(name, std::make_pair(authors[*i], authors[*i]));
      }
    }
    
    // Code copied from Gnuplot -r70
    char tmpname[]="/tmp/svndigestXXXXXX";
    int fd=mkstemp(tmpname);  // mkstemp return a file descriptor
    if (fd == -1)
      throw std::runtime_error(std::string("Failed to get unique filename: ") +
                               tmpname);
    // Jari would like to do something like 'std::ofstream tmp(fd);'
    // but has to settle for (which is stupid since the file is
    // already open for writing.
    std::ofstream tmp(tmpname);
      



    ifstream is(path().c_str());
    string line;
    bool found_copyright = false;
    bool after_copyright = false;
    string prefix;
    while(getline(is, line)){
      if (after_copyright) 
        tmp << line << "\n";
      else if (found_copyright){
        // check if line is end of copyright statement, i.e. contains
        // no alphanumerical character
        after_copyright = true;
        for (size_t i=0; i<line.size()&&after_copyright; ++i)
          if (isalnum(line[i]))
            after_copyright = false;
        if (after_copyright)
          tmp << line << "\n";
          
      }
      else {
        // check whether copyright starts on this line
        string::iterator i = search(line.begin(), line.end(), "Copyright (C)");
        
        if (i==line.end())
          tmp << line << "\n";
        else {
          prefix = line.substr(0, distance(line.begin(), i));
          found_copyright = true;
          if (!found_copyright) 
            tmp << line << "\n";
          else {
            // Printing copyright statement
            for (Container::const_iterator i=copyright.begin();
                 i!=copyright.end();) {
              tmp << prefix << "Copyright (C) "
                   << 1900+i->first;
              Container::const_iterator j = i;
              while (++j!=copyright.end() && i->second == j->second){
                tmp << ", " << 1900+j->first;
              }
              // printing authors
              for (set<string>::iterator a=i->second.begin();
                   a!=i->second.end(); ++a){
                if (a!=i->second.begin())
                  tmp << ",";
                tmp << " " << *a;
              }
              tmp << "\n";
              i = j;
            }
          }
        }
      }
    }
    is.close();
    tmp.close();
    close(fd);
    // finally move printed temporary file to original file
    rename(tmpname, path().c_str());
  }
}} // end of namespace svndigest and namespace theplu