source: trunk/lib/CopyrightStats.cc @ 1358

// $Id: CopyrightStats.cc 1358 2011-05-31 23:38:22Z peter $

/*
  Copyright (C) 2011 Peter Johansson

  This file is part of svndigest, http://dev.thep.lu.se/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 3 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 svndigest. If not, see <http://www.gnu.org/licenses/>.
*/

#include "CopyrightStats.h"
#include "LineTypeParser.h"
#include "SVNblame.h"
#include "SVNinfo.h"
#include "SVNlog.h"

#include <subversion-1/svn_types.h>

#include <cassert>
#include <iostream>

namespace theplu {
namespace svndigest {

  CopyrightStats::CopyrightStats(const std::string& path, bool ignore_cache,
                                 std::map<std::string, Alias>& author2alias,
                                 const std::map<int, svn_revnum_t>& year2rev)
    : author2alias_(author2alias), path_(path)
  {
    init(ignore_cache, year2rev);
  }


  void CopyrightStats::init(bool ignore_cache, 
                            const std::map<int, svn_revnum_t>& year2rev)
  {
    svn_revnum_t cache_rev = 0;
    if (!ignore_cache)
      cache_rev = load_cache("");
    SVNinfo info(path_);
    if (cache_rev >= info.last_changed_rev())
      return;

    // reset stats if cache was invalid
    if (cache_rev == 0) 
      reset();

    parse(cache_rev+1, year2rev);
    write_cache("");
  }


  svn_revnum_t CopyrightStats::load_cache(const std::string& filename)
  {
    // FIXME
    return 0;
  }


  const std::map<int, std::set<Alias> > CopyrightStats::map(void) const
  {
    return year2alias_;
  }


  void CopyrightStats::parse(svn_revnum_t first_rev,
                             const std::map<int, svn_revnum_t>& year2rev)
  {
    std::map<int, svn_revnum_t>::const_iterator yearrev=year2rev.begin();
    SVNlog log(path_);
    typedef SVNlog::container::const_iterator log_iterator;
    log_iterator commit = log.commits().begin();
    while (commit->revision() < first_rev)
      ++commit;
    log_iterator end = log.commits().end();
    // loop over all commits
    for ( ; commit!=end; ++commit) {
      // assure yearrev correspond to commit
      while (yearrev->second < commit->revision()) {
        ++yearrev;
        assert(yearrev!=year2rev.end());
      }
      
      // skip if author already has copyright for this year.
      std::map<int, std::set<Alias> >::const_iterator year_aliases = 
        year2alias_.find(yearrev->first);
      
      SVNblame svn_blame(path_, commit->revision());
      LineTypeParser parser(path_);
      const std::string& name = commit->author();
      
      // find username in map of aliases
      std::map<std::string, Alias>::iterator alias = 
        author2alias_.lower_bound(name);
      
      // if alias not found for author
      if (alias == author2alias_.end() || alias->first!=name) {
        std::cerr << "svncopyright: warning: no copyright alias found for `" 
                  << name << "'\n";
        // insert alias to avoid multiple warnings.
        Alias a(name, author2alias_.size());
        // FIXME use insert with hint
        author2alias_[name] = a;
        alias = author2alias_.find(name);
        assert(alias!=author2alias_.end());
      }
      
      // loop over lines
      while (svn_blame.valid()) {
        int lt = parser.parse(svn_blame.line());
        if ((lt==LineTypeParser::code || lt==LineTypeParser::comment) && 
            svn_blame.revision()==commit->revision()) {
          year2alias_[yearrev->first].insert(alias->second);
          break;
        }
        svn_blame.next_line();
      }
    }
  }


  void CopyrightStats::reset(void)
  {
    year2alias_.clear();
  }


  void CopyrightStats::write_cache(const std::string& filename)
  {
    // FIXME
  }

}}