сlient = pysvn.Client()
t = pysvn.Transaction(repos, txn)
changes = t.changed()
    for path in changes:
        # src - лежит в папке hooks svn репозитория, там же где и pre-commit скрипт
        # path - здесь ожидается, что path это полный путь к файлу, который будет коммититься, как получить этот путь?
        client.copy(path, 'src')

#!/usr/bin/env python

import sys
import pysvn

trans = pysvn.Transaction(*sys.argv[1:])
for path in trans.changed():
    sys.stderr.write('content: %s' % trans.cat(path))
sys.exit(1)

#!c:\python26\python.exe

import os, sys
import pysvn
import re
import utils
import logging

CURRENT_DIR = os.path.dirname(os.path.realpath(__file__))
CHECK_DIR = os.path.join(CURRENT_DIR, 'src')

CHECKSTYLE_PATTERN = r'checkstyle\s*\=\s*(\w+)'

# setup logger
logging.basicConfig
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

formatter = logging.Formatter('%(asctime)s - %(filename)s - %(levelname)s - %(message)s')
handler = logging.FileHandler(os.path.join(CURRENT_DIR, 'pre-commit.log'), mode='w')
handler.setFormatter(formatter)
logger.addHandler(handler)

def main (repos, txn):

    trans = pysvn.Transaction(repos, txn)
    
    helper = utils.Helper(CURRENT_DIR, CHECK_DIR)

    # checking value of 'skip.checkstyle' option
    # if it has been set in log message
    logMsg = trans.revpropget('svn:log')
    s = re.compile(CHECKSTYLE_PATTERN).search(logMsg)

    if s != None and s.group(1) == 'false':
        logger.info('skipping checkstyle')
        sys.exit(0)

    changes = trans.changed()
    
    modified = []
    added = []
    all_changes = []

    for entry in changes.keys():
        if entry.endswith('.java'):
            if changes.get(entry)[0] == 'R':
                modified.append(entry)
                all_changes.append(entry)

            elif changes.get(entry)[0] == 'A':
                added.append(entry)
                all_changes.append(entry)

    logger.info('%s files modified' % len(modified))
    logger.info('%s files added' % len(added))
 
    # preparing check dir
    if not os.path.exists(CHECK_DIR):
        os.makedirs(CHECK_DIR)
    helper.cleanDir(CHECK_DIR)

    # recieving contents of files
    for path in all_changes:
        if (path.endswith('.java')):
            content = trans.cat(path)
            
            filePath = helper.getExpandedWorkingCopyPath(path, root=CHECK_DIR)
            helper.prepareDir(filePath)
            f = file(filePath, 'w')
            f.write(content)
            f.close()
    
    logger.info('running checkstyle over %s' % len(all_changes))
    cur_errors = helper.runCheckstyle(CURRENT_DIR, CHECK_DIR)
    if (cur_errors > 0):
        helper.cleanDir(CHECK_DIR)
        helper.exportRepositoryFiles(modified)
        logger.info('running checkstyle over %s' % len(modified))
        prev_errors = helper.runCheckstyle(CURRENT_DIR, CHECK_DIR)

        if cur_errors > prev_errors:
            sys.stderr.write('\nCURRENT amount of checkstyle violations:\t- %s' % cur_errors)
            sys.stderr.write('\nPREVIOUS amount of checkstyle violations:\t- %s' % prev_errors)

            sys.exit(1)

if __name__ == '__main__':
    if len(sys.argv) < 3:
        sys.stdout.write("\nUsage: %s REPOS TXN\n" % (sys.argv[0]))
    else:
        sys.exit(main(sys.argv[1], sys.argv[2]))

import errno
import logging
import os
import pysvn
import re
import shutil
import subprocess as subp
import sys

WARNING_PATTERN = r':\swarning:\s|:\serror:\s'

class Helper:

    def __init__(self, curDir, checkDir):
        self.curDir = curDir
        self.checkDir = checkDir
        self.svn_client = pysvn.Client()

        logger = logging.getLogger(__name__)
        logger.setLevel(logging.DEBUG)
        formatter = logging.Formatter('%(asctime)s - %(filename)s - %(levelname)s - %(message)s')
        handler = logging.FileHandler(os.path.join(curDir, 'pre-commit.log'), mode='a')
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        self._logger = logger

    def prepareDir(self, filename):
        dir = os.path.dirname(filename)
        if not os.path.exists(dir):
            os.makedirs(dir)

    def cleanDir(self, dir):
        """ Removes all content of the specified directory """
        self._logger.info('cleaning dir \'%s\'' % dir)
        if os.path.exists(dir):
            for root, dirs, files in os.walk(dir):
                for f in files:
                    os.unlink(os.path.join(root, f))
                for d in dirs:
                    shutil.rmtree(os.path.join(root, d))
        else:
            raise OSError(errno.ENOENT, 'The system cannot find the file specified: \'%s\'' % dir) 
            
    def formatDirPath(self, path):
        """Appends trailing separator to non-empty path if it is missing.

        Args:
            path:  path string, which may be with or without a trailing separator,
              or even empty or None

        Returns:
            path unchanged if path evaluates to False or already ends with a trailing
            separator; otherwise, a / separator is appended
        """
        if path and not path.endswith('/'):
            path = ''.join([path, '/'])
        return path

    def useLocalOsSep(self, path):
        """Return path with all / characters replaced with os.sep, to be OS-agnostic.

        Args:
            path: an SVN path (either working copy path or relative path, but not a
              full repository URL) that uses the canonical / separators
        """
        return path.replace('/', os.sep)

    def getExpandedWorkingCopyPath(self, path, root=None):
        """Returns expanded, local, native filesystem working copy path.

        Args:
            path: path to expand and convert to local filesystem directory separators
            root: if present, prepended to path first
        """
        path = self.useLocalOsSep(path)

        if root:
            # prepend (Windows-compatible) working copy root if one was supplied
            path = os.path.join(self.useLocalOsSep(root), path)

        path = self.getExpandedPath(path)

        return path

    def getExpandedPath(self, path):
        """Returns an expanded, normalized, absolute path.

        Args:
            path: path (possibly relative, possibly containing environment variables,
              etc.) to be expanded, normalized and made absolute

        Returns:
            absolute path, after expanding any environment variables and "~", then
            removing excess . and .. path elements
        """
        return os.path.abspath(
          os.path.normpath(
              os.path.expanduser(
                  os.path.expandvars(path))))

    def exportFiles(self, files):
        self._logger.info('exporting files...')
        for src in files.keys():
            dest = files[src]
            self.prepareDir(dest)
            self.svn_client.export(src, dest)

    def runCheckstyle(self, wd, path):
        """ Returns amount of checkstyle violations
        """
        self._logger.info('running checkstyle')
        cmd = 'ant -Dcheck.dir=%s' % path
        p = subp.Popen(cmd, shell = True, stdout = subp.PIPE, stderr = subp.STDOUT, cwd=wd)
        m = re.compile(WARNING_PATTERN)
        errors = len(m.findall(p.communicate()[0]))
        return errors

    def exportRepositoryFiles(self, changes):
        self._logger.info(self.svn_client)
        exportList = {}
        for entry in changes:
            src =''.join(['svn://localhost/', entry])
            dest = self.getExpandedWorkingCopyPath(entry, root=self.checkDir)
            exportList[src] = dest
            self.exportFiles(exportList)

"""
A subversion pre-commit hook that validates the commited files for
checkstyle violations.
"""

__authors__ = [
    # alphabetical order by last name, please
    'sober',
]

import os, sys
import pysvn
import re
import utils
import logging
#import timeit

# magic keyword which allows to skip checkstyle
CHECKSTYLE_PATTERN = '.*skipcheckstyle.*'
# directory in which this script is located
CURRENT_DIR = os.path.dirname(os.path.realpath(__file__))
# directory which should contain files to be checked
CHECK_DIR = os.path.join(CURRENT_DIR, 'src\\')
# path to the checkstyle report
ERRORS_REPORT_PATH = os.path.join(CURRENT_DIR, 'checkstyle\\checkstyle_errors.xml')

# setup LOGGER
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.DEBUG)

FORMATTER = logging.Formatter('%(asctime)s - %(filename)s - %(levelname)s - %(message)s')
HANDLER = logging.FileHandler(os.path.join(CURRENT_DIR, 'pre-commit.log'), mode='w')
HANDLER.setFormatter(FORMATTER)
LOGGER.addHandler(HANDLER)

def main (repos, txn):
    """ Hook entry point """
    trans = pysvn.Transaction(repos, txn)
    helper = utils.Helper(CURRENT_DIR)

    # checking the value of 'skip.checkstyle' option (set in the commit log)
    log_msg = trans.revpropget('svn:log')
    match = re.search(CHECKSTYLE_PATTERN, log_msg)

    if match is not None:
        LOGGER.info('skipping checkstyle')
        sys.exit(0)

    changes = trans.changed()
    all_changes = []
    modified = []

    for path in changes.keys():
        if path.endswith('.java'):
            if changes.get(path)[0] is not 'D':
                all_changes.append(path)

            if changes.get(path)[0] is 'R':
                modified.append(path)

    if len(all_changes) > 0:

        # preparing check dir
        if not os.path.exists(CHECK_DIR):
            os.makedirs(CHECK_DIR)
        else:
            helper.clean_dir(CHECK_DIR)

        # recieving contents of the files
        for path in all_changes:
            file_path = \
                helper.get_expanded_working_path(re.search(r'.*trunk/(.*)', path).group(1),root=CHECK_DIR)
            helper.prepare_dir(file_path)
            f = file(file_path, 'w')
            f.write(trans.cat(path))
            f.close()

        LOGGER.info('Executing checkstyle over committed files ...')
        helper.run_checkstyle(CHECK_DIR)

        cur_report = helper.get_checkstyle_report(ERRORS_REPORT_PATH)
        helper.clean_dir(CHECK_DIR)

        helper.export_repos_files(modified, CHECK_DIR)
        LOGGER.info('Executing checkstyle over repository versions of commited files ...')
        helper.run_checkstyle(CHECK_DIR)
        prev_report = helper.get_checkstyle_report(ERRORS_REPORT_PATH)
        
        error_msg = ''
        for path in cur_report.keys():
            msg_pattern = '\nAmount of checkstyle violations in file \'%s\' has increased from %s to %s'

            if path not in prev_report.keys() and cur_report[path] > 0:
                error_msg += (msg_pattern % (path[len(CHECK_DIR):], '0', cur_report[path]))

            elif prev_report[path] < cur_report[path]:
                error_msg += (msg_pattern % (path[len(CHECK_DIR):], prev_report[path], cur_report[path]))

        LOGGER.info(error_msg)

        if len(error_msg) > 0:
            sys.stderr.write(error_msg)
            return 1

if __name__ == '__main__':
    if len(sys.argv) < 3:
        sys.stdout.write("\nUsage: %s REPOS TXN\n" % (sys.argv[0]))
    else:
        sys.exit(main(sys.argv[1], sys.argv[2]))
        # this code is for testing purpose
        #t = timeit.Timer('main(\'%s\', \'%s\')' % (sys.argv[1], sys.argv[2]), 'from __main__ import main')
        #aver = t.timeit(number=1)
        #LOGGER.info('Hook execution time is %s sec' % aver)

""" Common utils used for svn pre-commit hook """

import os
import pysvn
import shutil
import subprocess as subp
from xml.dom import minidom

class Helper:
    """ help class which aggregates utils used for svn pre-commit hook """

    def __init__(self, cur_dir):
        self.cur_dir = cur_dir
        self.svn_client = pysvn.Client()

    def prepare_dir(self, filename):
        """ Creates directory tree if not exists """
        dir_path = os.path.dirname(filename)
        if not os.path.exists(dir_path):
            os.makedirs(dir_path)

    def clean_dir(self, dir):
        """ Removes all content of the specified directory """
        #self._logger.info('cleaning dir \'%s\'' % dir)
        if os.path.exists(dir):
            for root, dirs, files in os.walk(dir):
                for file_path in files:
                    os.unlink(os.path.join(root, file_path))
                for dir_path in dirs:
                    shutil.rmtree(os.path.join(root, dir_path))
        else:
            raise OSError('The system cannot find the file specified: \'%s\'' % dir) 

    def use_local_os_sep(self, path):
        """Return path with all / characters replaced with os.sep, to be OS-agnostic.

        Args:
            path: an SVN path (either working copy path or relative path, but not a
              full repository URL) that uses the canonical / separators
        """
        return path.replace('/', os.sep)

    def get_expanded_working_path(self, path, root=None):
        """Returns expanded, local, native filesystem working copy path.

        Args:
            path: path to expand and convert to local filesystem directory separators
            root: if present, prepended to path first
        """
        path = self.use_local_os_sep(path)

        if root:
            # prepend (Windows-compatible) working copy root if one was supplied
            path = os.path.join(self.use_local_os_sep(root), path)

        path = self.get_expanded_path(path)

        return path

    def get_expanded_path(self, path):
        """Returns an expanded, normalized, absolute path.

        Args:
            path - path (possibly relative, possibly containing environment variables,
              etc.) to be expanded, normalized and made absolute

        Returns:
            absolute path, after expanding any environment variables and "~", then
            removing excess . and .. path elements
        """
        return os.path.abspath(
          os.path.normpath(
              os.path.expanduser(
                  os.path.expandvars(path))))

    def export_files(self, files):
        """ Export list of files specified as the dictionary keys
            to the path specified as dictionary values """
        #self._logger.info('exporting files...')
        for src in files.keys():
            dest = files[src]
            self.prepare_dir(dest)
            self.svn_client.export(src, dest)

    def run_checkstyle(self, path):
        """ Executes checkstyle validation as the separate process
            which executes the Ant checkstyle task

            Args:
                path - path that should be checked
        """
        #self._logger.info('running checkstyle')
        cmd = 'ant -Dcheck.dir=%s' % path
        proc = subp.Popen(cmd, shell = True, stdout = subp.PIPE, stderr = subp.STDOUT, cwd=self.cur_dir)
        proc.communicate()

    def export_repos_files(self, changes, path):
        """ Exports committed files from transaction to the specified path
            Args:
                changes - list of changed files
                path - root destination of the files being exported
        """
        #self._logger.info('Exporting %s files from repository' % len(changes))
        export_list = {}
        for entry in changes:
            src = ''.join(['svn://localhost/', entry])
            dest = self.get_expanded_working_path(entry, root=path)
            export_list[src] = dest
        self.export_files(export_list)

    def get_checkstyle_report(self, path):
        """ Returns checkstyle report as a dictionary which contains amount
            of checkstyle violations for every file
        Args:
            path - path to the checkstyle report
        Returns:
            dictionary which contains amount of checkstyle violations for every file
        """
        report = {}
        xmldoc = minidom.parse(path)
        file_tags = xmldoc.getElementsByTagName('file')
        for tag in file_tags:
            key = tag.getAttribute('name')
            value = len(tag.getElementsByTagName('error'))
            if key in report:
                report[key] += value
            else:
                report[key] = value

        return report

"""
A subversion pre-commit hook that validates the commited files for
checkstyle violations.
"""

__authors__ = [
    # alphabetical order by last name, please
    'sober',
]

import logging
import os, sys
import pysvn
import re
import shutil
import subprocess as subp
from xml.dom import minidom
#import timeit

# directory in which this script is located
CURRENT_DIR = os.path.dirname(os.path.realpath(__file__))
SVN_CLIENT = pysvn.Client()

# setup logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(filename)s - %(levelname)s - %(message)s')
handler = logging.FileHandler(os.path.join(CURRENT_DIR, 'pre-commit.log'), mode='w')
handler.setFormatter(formatter)
logger.addHandler(handler)

def prepare_dir(filename):
    """ Creates directory tree if not exists """
    dir_path = os.path.dirname(filename)
    if not os.path.exists(dir_path):
        os.makedirs(dir_path)

def clean_dir(path):
    """ Removes all content of the specified directory """
    #logger.info('cleaning dir \'%s\'' % dir)
    if os.path.exists(path):
        for root, dirs, files in os.walk(path):
            for file_path in files:
                os.unlink(os.path.join(root, file_path))
            for dir_path in dirs:
                shutil.rmtree(os.path.join(root, dir_path))
    else:
        raise OSError('The system cannot find the file specified: \'%s\'' % path) 

def use_local_os_sep(path):
    """Return path with all / characters replaced with os.sep, to be OS-agnostic.

    Args:
        path: an SVN path (either working copy path or relative path, but not a
          full repository URL) that uses the canonical / separators
    """
    return path.replace('/', os.sep)

def get_expanded_working_path(path, root=None):
    """Returns expanded, local, native filesystem working copy path.

    Args:
        path: path to expand and convert to local filesystem directory separators
        root: if present, prepended to path first
    """
    path = use_local_os_sep(path)

    if root:
        # prepend (Windows-compatible) working copy root if one was supplied
        path = os.path.join(use_local_os_sep(root), path)

    path = get_expanded_path(path)

    return path

def get_expanded_path(path):
    """Returns an expanded, normalized, absolute path.

    Args:
        path - path (possibly relative, possibly containing environment variables,
          etc.) to be expanded, normalized and made absolute

    Returns:
        absolute path, after expanding any environment variables and "~", then
        removing excess . and .. path elements
    """
    return os.path.abspath(
      os.path.normpath(
          os.path.expanduser(
              os.path.expandvars(path))))

def export_files(files):
    """ Export list of files specified as the dictionary keys
        to the path specified as dictionary values """
    #logger.info('exporting files...')
    for src in files:
        dest = files[src]
        prepare_dir(dest)
        SVN_CLIENT.export(src, dest)

def run_checkstyle(path):
    """ Executes checkstyle validation as the separate process
        which executes the Ant checkstyle task

        Args:
            path - path that should be checked
    """
    #logger.info('running checkstyle')
    cmd = 'ant -Dcheck.dir=%s' % path
    proc = subp.Popen(cmd, shell = True, stdout = subp.PIPE, stderr = subp.STDOUT, cwd=CURRENT_DIR)
    proc.communicate()

def export_repos_files(changes, path):
    """ Exports committed files from transaction to the specified path
        Args:
            changes - list of changed files
            path - root destination of the files being exported
    """
    #logger.info('Exporting %s files from repository' % len(changes))
    export_list = {}
    for entry in changes:
        src = ''.join(['svn://localhost/', entry])
        dest = get_expanded_working_path(entry, root=path)
        export_list[src] = dest
    export_files(export_list)

def get_checkstyle_report(path):
    """ Returns checkstyle report as a dictionary which contains amount
        of checkstyle violations for every file
    Args:
        path - path to the checkstyle report
    Returns:
        dictionary which contains amount of checkstyle violations for every file
    """
    report = {}
    xmldoc = minidom.parse(path)
    file_tags = xmldoc.getElementsByTagName('file')
    for tag in file_tags:
        key = tag.getAttribute('name')
        value = len(tag.getElementsByTagName('error'))
        if key in report:
            report[key] += value
        else:
            report[key] = value

    return report

def main (repos, txn):
    """ Hook entry point """

    # magic keyword which allows to skip checkstyle
    checkstyle_pattern = '.*skipcheckstyle.*'
    
    # directory which should contain files to be checked
    check_dir = os.path.join(CURRENT_DIR, 'src\\')
    # path to the checkstyle report
    errors_report_path = os.path.join(CURRENT_DIR, 'checkstyle\\checkstyle_errors.xml')

    trans = pysvn.Transaction(repos, txn)

    # checking the value of 'skip.checkstyle' option (set in the commit log)
    log_msg = trans.revpropget('svn:log')
    if re.search(checkstyle_pattern, log_msg):
        logger.info('skipping checkstyle')
        sys.exit(0)

    changes = trans.changed()
    all_changes = []
    modified = []

    for path in changes:
        if path.endswith('.java'):
            status = changes.get(path)[0]
            if status is not 'D':
                all_changes.append(path)
            if status is 'R':
                modified.append(path)

    if all_changes:

        # preparing check dir
        if not os.path.exists(check_dir):
            os.makedirs(check_dir)
        else:
            clean_dir(check_dir)

        # recieving contents of the files
        for path in all_changes:
            file_path = \
                get_expanded_working_path(re.search(r'.*trunk/(.*)', path).group(1),root=check_dir)
            prepare_dir(file_path)
            f = file(file_path, 'w')
            f.write(trans.cat(path))
            f.close()

        logger.info('Executing checkstyle over committed files ...')
        run_checkstyle(check_dir)

        cur_report = get_checkstyle_report(errors_report_path)
        clean_dir(check_dir)

        export_repos_files(modified, check_dir)
        logger.info('Executing checkstyle over repository versions of commited files ...')
        run_checkstyle(check_dir)
        prev_report = get_checkstyle_report(errors_report_path)
        
        error_msg = ''
        for path in cur_report:
            msg_pattern = '\nAmount of checkstyle violations in file \'%s\' has increased from %s to %s'

            if path not in prev_report and cur_report[path] > 0:
                error_msg += (msg_pattern % (path[len(check_dir):], '0', cur_report[path]))

            elif prev_report[path] < cur_report[path]:
                error_msg += (msg_pattern % (path[len(check_dir):], prev_report[path], cur_report[path]))

        logger.info(error_msg)

        if error_msg:
            sys.stderr.write(error_msg)
            return 1

if __name__ == '__main__':
    if len(sys.argv) < 3:
        sys.stdout.write("\nUsage: %s REPOS TXN\n" % (sys.argv[0]))
    else:
        sys.exit(main(sys.argv[1], sys.argv[2]))
        # this code is for testing purpose
        #t = timeit.Timer('main(\'%s\', \'%s\')' % (sys.argv[1], sys.argv[2]), 'from __main__ import main')
        #aver = t.timeit(number=1)
        #logger.info('Hook execution time is %s sec' % aver)