vanessa-behavior 0.4.4

data/vendor/precommit1c/README.md

@@ -0,0 +1,89 @@
+## Набор утилит для автоматической разборки/сборки внешних обработок и отчетов, при помещении(commit) в git.
+
+### Что к чему
+----
+* pyv8unpack.py - python скрипт, получающий список помещаемых файлов при коммите, фильтрующий по расширению только внешние обработки/отчеты и запускающий внешнюю обработку для распаковки этих файлов. 
+* [V8Reader.epf](http://infostart.ru/public/106310/) - внешняя обработка 1С, которая с помощью [v8unpack](http://svn2.assembla.com/svn/V8Unpack/track/) разбирает внешние обработки, определяет нормальные наименования для каталогов форм, файлов модулей объектов и т.д. и раскладывает их в нормальную структуру папок. 
+* ibService - сервисная база данных на 1С, для запуска V8Reader.epf
+* pre-commit - собственно командный файл вызываемый git перед каждым помещением. Выполняет роль простой запускалки скрипта pyv8unpack.py 
+
+### Установка
+
+1. Зависимости: 
+    * python 3.3
+    * установленная платформа 1С предприятия. 
+    * git
+    * в случаии запуска из под wine, необходим и msscriptcontrol.
+
+2. По умолчанию считается, что пути к python.exe и git.exe находятса в переменной path, иначе необходимо указать явный путь в файлах pre-commit(для python) и pyv8unpack.py(для git)
+
+3. Путь к платформе находит автоматически, в случаии стандатной установки 1С. Если необходимо указать явно путь к платформе, необходимо: Указать переменную окружения PATH1C c путем к каталогу, где установленна 1С
+```
+set PATH1C = d:\program\
+```
+или создать файл ini рядом с файлом скрипта pyv8unpack.py или в домашней папке в корне, с именем precommit1c.ini и содеражнием:
+```
+[DEFAULT]
+onecplatfrorms = c:\program\1cv8\8.3.5.823\bin\1cv8.exe
+```
+
+4. Путь хранения исходных текстово разобранных обработок поумолчанию используется как **src** (для обеспечения совместимости со старыми версиями обработки), однако его можно переназначить в ini файле
+```
+[DEFAULT]
+source = plugin_source
+```
+
+5. Флажок изменеяющий корневую папку хранения исходных текстово разобранных обработок поумолчанию используется как корневая папка (для обеспечения совместимости со старыми версиями обработки), однако его можно переназначить в ini файле. Если изменить флажок на True - в каждой корневой папаке внешних обработок будет создан подкаталог текстово разобранных обработок.
+```
+[DEFAULT]
+source_in_source = False
+```
+
+6. Наконец содержимое каталога необходимо скопировать в каталог .git/hooks/ вашего проекта. 
+> *Примечание:* каталог .git по умолчанию скрыт.  
+
+```
+.git\
+    hooks\
+        pre-commit
+        V8Reader.epf
+        ibService 
+        pyv8unpack.py
+```
+
+##Запуск 
+
+После установки достаточно для проверки сделать commit для любого файла epf и в вашем репозитарии автоматически должна создаться папка *src* повторяющая полностью структуру проекта, те файлы которые были измененны или же добавленны распакуются в папки с аналогичным наименованием. 
+
+##Командная строка запуска
+
+```
+python pyv8unpack.py [-h] [--version] [-v] [--index] [--g] [--compile]
+                     [--type TYPE] [--platform PLATFORM]
+                     [inputPath] [output]
+
+Утилита для автоматической распаковки внешних обработок
+
+positional arguments:
+  inputPath            Путь к файлам необходимым для распаковки
+  output               Путь к каталогу, куда распаковывать
+
+optional arguments:
+  -h, --help           show this help message and exit
+  --version            show program's version number and exit
+  -v, --verbose        increases log verbosity for each occurence.
+  --index              Добавляем в индекс исходники
+  --g                  Запуситить чтение индекса из git и определить список
+                       файлов для разбора
+  --compile            Собрать внешний файл/обработку
+  --type TYPE          Тип файла для сборки epf, erf. По умолчанию авто epf
+  --platform PLATFORM  Путь к платформе 1С
+```
+
+##Ограничения
+
+Одинковыми именами файлы с разным расширением epf и erf называть не надо, т.к. каталоги с исходниками создаются только по наименованию без учета расширения и возможен конфликт. 
+Дополнительно необходима настройка git для возможности использования кирилических наименований внешних обработок ```git config --local core.quotepath false```
+##Что внутри
+
+как это работает: pyv8unpack.py повторяет полностью иерархию папок относительно корня репозитария только в папке SRC (от слова source) или ту которую вы определили в конфигурационном файлу , каждая для каждой измененной внешней обработки создается своя папка и туда с помощью v8unpack распаковывается помещаемая обработка, с помощью v8reader определяютса наименования макетов, форм, модуля обработки и переименовываются, переименования сохраняютса в служебном файле renames.txt , те файлы, которые невозмонжно определить или же носят чисто служебный характер, переносятса в каталог *und*

data/vendor/precommit1c/copy-to-hook.cmd

@@ -0,0 +1,11 @@
+@echo off
+
+@echo copy current version in bootstrap https://github.com/xUnitFor1C/xdd-bootstrap-1C
+
+xcopy .\ibService .\..\..\.git\hooks\ibService\ /Y /E /F
+xcopy .\pre-commit .\..\..\.git\hooks\ /Y /F
+xcopy .\v8Reader.epf .\..\..\.git\hooks\ /Y /F
+xcopy .\pyv8unpack.py .\..\..\.git\hooks\ /Y /F
+
+cd .\..\..\
+git config --local core.quotepath false

data/vendor/precommit1c/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+echo "Start hooks before commit for v8unpack erf and epf"
+python.exe .git/hooks/pyv8unpack.py --g --index

data/vendor/precommit1c/precommit1c.ini.example

@@ -0,0 +1,3 @@
+[DEFAULT]
+onecplatfrorms = D:\environ\onec\1cv8\8.3.4.465\bin\1cv8.exe
+source = plugin_source

data/vendor/precommit1c/pyv8unpack.py

@@ -0,0 +1,370 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import subprocess
+import shutil
+import logging
+import tempfile
+import re
+import platform
+import argparse
+from subprocess import PIPE
+
+__version__ = "0.0.3"
+
+logging.basicConfig(level=logging.INFO) # DEBUG => print ALL msgs
+log = logging.getLogger("pyv8unpack")
+
+modified = re.compile('^(?:M|A)(\s+)(?P<name>.*)')
+
+
+def get_config_param(param):
+    '''
+    parse config file and find in them source dir
+    '''
+
+    curdir = os.curdir
+    if '__file__' in globals():
+        curdir = os.path.dirname(os.path.abspath(__file__))
+
+
+    config = None
+    for loc in curdir, os.curdir, os.path.expanduser("~"):
+        try:
+            with open(os.path.join(loc, "precommit1c.ini")) as source:
+                if sys.version_info<(3,0,0):
+                    from ConfigParser import ConfigParser  # @NoMove @UnusedImport
+                else:
+                    from configparser import ConfigParser
+
+                config = ConfigParser()
+                config.read_file(source)
+                break
+        except IOError:
+            pass
+
+    if not config is None and config.has_option("DEFAULT", param):
+        value = config.get("DEFAULT", param)
+        return value
+
+
+    return None
+
+
+def get_path_to_1c():
+    """
+    get path to 1c binary.
+    fist env, "PATH1C"
+    two env "PROGRAMFILES" on windows
+    three /opt/1c - only linux
+
+    """
+
+    cmd = os.getenv("PATH1C")
+    if not cmd is None:
+        cmd = os.path.join(cmd, "1cv8")
+        maxversion = max(list(filter((lambda x: '8.' in x), os.listdir(cmd))))
+        if maxversion is None:
+            raise Exception("not found verion dirs")
+        cmd = os.path.join(cmd, maxversion+os.path.sep+"bin"+os.path.sep+"1cv8.exe")
+
+        if not os.path.isfile(cmd):
+            raise Exception("file not found %s" % (cmd))
+
+        return cmd
+
+    #read config
+
+    curdir = os.curdir
+    if '__file__' in globals():
+        curdir = os.path.dirname(os.path.abspath(__file__))
+
+
+    onecplatfrorm_config = get_config_param("onecplatfrorm")
+    if not onecplatfrorm_config is None:
+        return onecplatfrorm_config
+
+    if platform.system() == "Darwin":
+        raise Exception("MacOS not run 1C")
+    elif platform.system() == "Windows":
+        program_files = os.getenv("PROGRAMFILES(X86)")
+        if program_files is None:
+            #FIXME: проверить архетиктуру.
+            program_files = os.getenv("PROGRAMFILES")
+            if program_files is None:
+                raise "path to Program files not found";
+        cmd = os.path.join(program_files, "1cv8")
+        maxversion = max(list(filter((lambda x: '8.' in x), os.listdir(cmd))))
+        if maxversion is None:
+            raise Exception("not found verion dirs")
+        cmd = os.path.join(cmd, maxversion + os.path.sep + "bin"+os.path.sep+"1cv8.exe")
+
+        if not os.path.isfile(cmd):
+            raise Exception("file not found %s" % (cmd))
+
+    else:
+        cmd = subprocess.Popen(["which", "1cv8"], stdout=PIPE).communicate()[0].strip()
+
+    return cmd
+
+def get_list_of_comitted_files():
+    """
+    Retun a list of files abouts to be decompile
+    """
+    files = []
+    output = []
+    try:
+        output = subprocess.check_output(['git','diff-index', '--name-status', '--cached','HEAD']
+            ).decode("utf-8")
+    except subprocess.CalledProcessError:
+        try:
+            output = subprocess.check_output(['git', 'status', '--porcelain']).decode("utf-8")
+        except subprocess.CalledProcessError:
+            print("Error diff files get")
+            return files
+
+    for result in output.split("\n"):
+        logging.info(result)
+        if result != '':
+            match = modified.match(result)
+            if match:
+                files.append(match.group('name'))
+
+    return files
+
+def decompile(list_of_files, source=None, platform=None):
+    """
+    Main functions doing be decompile
+    возвращает list
+    """
+
+    #list of files to decompile and results decompile
+    dataprocessor_files = []
+
+    #set the exit code
+    exit_code = 0
+
+    #Find datapocessor files
+    for filename in list_of_files:
+        #Check the file extensions
+        logging.debug("file to check %s" % filename)
+        if filename[-3:] in ['epf', 'erf']:
+            dataprocessor_files.append(filename)
+            logging.debug("file %s" % filename)
+            continue
+    if len(dataprocessor_files) == 0:
+        exit(exit_code)
+
+    source_dir = source or get_config_param("source")
+    if source_dir is None:
+        source_dir = "src"
+
+    #получаем флажок того, что исходники располагаются в подпапке источника
+    source_in_source = get_config_param("source_in_source")
+    if source_in_source is None:
+        source_in_source = False
+    else:
+        if source_in_source == "True":
+            source_in_source = True
+        else:
+            source_in_source = False
+            
+    dirsource = os.path.abspath(os.path.join(os.path.curdir, source_dir))
+    curabsdirpath = os.path.abspath(os.path.curdir)
+    pathbin1c = platform or get_path_to_1c()
+    returnlist = []
+
+    for filename in dataprocessor_files:
+        logging.info("file %s" % filename)
+ 
+        fullpathfile = os.path.abspath(filename)
+        basename = os.path.splitext(os.path.basename(filename))[0]
+        fullbasename = os.path.basename(filename)
+        newdirname = os.path.dirname(filename)
+
+        #если исходники в подпаке источника, меняем путь
+        if source_in_source:
+          dirsource = os.path.abspath(os.path.join(os.path.curdir, newdirname, source_dir))
+
+
+        #Скопируем сначало просто структуру каталогов.
+        if not os.path.exists(dirsource):
+            os.makedirs(dirsource)
+        #для каждого файла определим новую папку.
+        if source_in_source:
+          logging.debug("{} {}".format(dirsource, basename))
+          newsourcepath = os.path.join(dirsource, basename)
+        else:  
+          logging.debug("{} {} {}".format(dirsource, newdirname, basename))
+          newsourcepath = os.path.join(dirsource, newdirname, basename)
+          
+        if(os.path.isabs(newdirname)):
+            newsourcepath = os.path.join(dirsource, basename)
+        if not os.path.exists(newsourcepath):
+            logging.debug("create new dir %s" % newsourcepath)
+            os.makedirs(newsourcepath)
+        else:
+            shutil.rmtree(newsourcepath, ignore_errors=True)
+
+        logging.debug("file to copy %s, new path %s, new file %s"
+            % (filename, newsourcepath, os.path.join(newsourcepath, fullbasename))
+        )
+
+        formatstring = format('/C"decompile;pathtocf;%s;pathout;%s;ЗавершитьРаботуПосле;"' % (fullpathfile, newsourcepath))
+        base = '/F"'+os.path.join(curabsdirpath,".git", "hooks","ibService")+'"'
+        V8Reader = '/execute"'+os.path.join(curabsdirpath,".git", "hooks", "v8Reader", "V8Reader.epf")+'"'
+        tempbat = tempfile.mktemp(".bat")
+        logging.debug("formatstring is %s , base is %s, V8Reader is %s, temp \
+            is %s" % (formatstring, base, V8Reader, tempbat))
+
+        with open(tempbat, 'w', encoding='cp866') as temp:
+            temp.write('@echo off\n')
+            temp.write(format('"%s" %s /DisableStartupMessages %s %s' % (pathbin1c,
+                            base, V8Reader, formatstring))
+                       )
+            temp.close()
+            result = subprocess.check_call(['cmd.exe', '/C', tempbat])
+            assert result == 0, format("Не удалось разобрать\
+                                обработку %s" % (fullpathfile))
+            if not result == 0:
+                logging.error(format("Не удалось разобрать \
+                    обработку %s" % (fullpathfile)))
+                raise format("Не удалось разобрать\
+                                обработку %s" % (fullpathfile))
+            returnlist.append(newsourcepath)
+            logging.info("Разобран в %s" % (newsourcepath))
+
+    return returnlist
+
+def add_to_git(pathlists):
+
+    for l in pathlists:
+        result = subprocess.check_call(['git', 'add', '--all', l])
+        if not result == 0:
+            logging.error(result)
+            exit(result)
+
+def compilefromsource(input, output, ext):
+    import codecs
+
+    assert not input is None, "Не указан путь к входящему каталогу"
+    assert not output is None, "Не указан путь к исходящему файлу"
+
+    extfile = "epf" if ext == "auto" else ext
+
+    dirsource = os.path.abspath(os.path.join(os.path.curdir, input))
+    if not os.path.exists(dirsource) or not os.path.isdir(dirsource):
+        raise "Не существует входящего каталога"
+
+    renamesFile = os.path.join(dirsource, "renames.txt")
+    if not os.path.exists(renamesFile):
+        raise "Не существует файла {}".format(renamesFile)
+    tempPath = tempfile.mkdtemp()
+
+    with codecs.open(renamesFile, "rb", encoding='utf-8') as r:
+        lines = r.read()
+        lines = lines.split('\r\n')
+        for l in lines:
+            if l.startswith(u'\ufeff'):
+                l = l[1:]
+            listline = l.split("-->") 
+            if len(listline) < 2:
+                continue
+            log.debug(l)
+            newPath = os.path.join(tempPath, listline[0])
+            dirname = os.path.dirname(newPath)
+            if not os.path.exists(dirname):
+                os.mkdir(dirname)
+            oldPath = os.path.join(dirsource,
+                                   listline[1].replace(
+                                   "\\", os.path.sep)
+                                   )
+
+            if os.path.isdir(oldPath):
+                #tempFile = tempfile.mkstemp()
+                newPath = os.path.join(tempPath, listline[0])
+                shutil.copytree(oldPath, newPath)
+            else:
+                log.debug(oldPath)
+                shutil.copy(
+                    os.path.normpath(oldPath),
+                    newPath
+                )
+
+        #вызовем v8unpack, для сборки файла из исходников.
+        tempFile = tempfile.mktemp("."+extfile)
+        log.debug('unpackv8 -B "{}" "{}"'.format('{}'.format(tempPath), tempFile))
+        result = subprocess.check_call(
+            ['unpackv8',
+             '-B',
+             '{}'.format(tempPath),
+             tempFile]
+        )
+
+        log.debug("copy from {} to {}".format(tempFile, output))
+        assert result == 0, "Не удалось упаковать каталог {}".format(tempPath)
+        shutil.move(tempFile, output)
+
+        return output
+
+def main():
+
+    parser = argparse.ArgumentParser(description="Утилита \
+        для автоматической распаковки внешних обработок")
+    parser.add_argument("--version", action="version",
+        version="%(prog)s {}".format(__version__))
+    parser.add_argument("-v", "--verbose", dest="verbose_count",
+        action="count", default=0,
+        help="increases log verbosity for each occurence.")
+    parser.add_argument("--index", action="store_true",
+        default=False, help="Добавляем в индекс исходники")
+    parser.add_argument("--g", action="store_true", default=False,
+        help="Запуситить чтение индекса из git и определить\
+        список файлов для разбора")
+    parser.add_argument("--compile", action="store_true", default=False,
+                        help = "Собрать внешний файл/обработку")
+    parser.add_argument("--type", action="store", default="auto",
+                        help="Тип файла для сборки epf, erf. По умолчанию авто epf")
+    parser.add_argument("--platform", action="store", help="Путь \
+        к платформе 1С")
+    parser.add_argument("inputPath", nargs="?", help="Путь к \
+        файлам необходимым для распаковки")
+    parser.add_argument("output", nargs="?", help="Путь к \
+        каталогу, куда распаковывать")
+
+    args = parser.parse_args()
+
+    log.setLevel(max(3 - args.verbose_count, 0) * 10)
+
+    if args.g is True:
+        files = get_list_of_comitted_files()
+        indexes = decompile(files, args.output, args.platform)
+        if args.index is True:
+            add_to_git(indexes)
+
+    if(args.compile):
+        compilefromsource(args.inputPath, args.output, args.type)
+    if args.inputPath is not None:
+        files = [os.path.abspath(
+            os.path.join(os.path.curdir, args.inputPath))]
+        if os.path.isdir(files[0]):
+            rootDir = os.path.abspath(
+                        os.path.join(os.path.curdir, args.inputPath));
+            files=[]
+            for dirName, subdirList, fileList in os.walk(rootDir):
+                absdir = dirName[len(rootDir)+1:]
+                if '.git' in subdirList:
+                    subdirList.remove('.git')
+                if 'src' in subdirList:
+                    subdirList.remove('src')
+                for fname in fileList:
+                    files.append(os.path.join(absdir,fname))
+                
+        decompile(
+            files, args.output, args.platform)
+
+
+if __name__ == '__main__':
+    sys.exit(main())

data/vendor/precommit1c/tests/TestFixture.cmd

@@ -0,0 +1,13 @@
+@echo off
+setlocal
+
+set mainDir=C:\Projects\xDD\precommit1c
+	rem set mainDir=%CD%
+set path1Cbin="C:\Program Files (x86)\1cv82\8.2.19.68\bin\1cv8.exe"
+set testName=Fixture
+
+set testDir=%mainDir%\tests
+
+rd /S /Q %testDir%\testSrc\%testName%
+%path1Cbin% /F"%mainDir%\ibService"  /DisableStartupMessages /execute "%mainDir%\V8Reader.epf" /C"decompile;pathtocf;%testDir%\%testName%.epf;pathout;%testDir%\testSrc\%testName%;�������쐠���㏮᫥;" 
+endlocal

data/vendor/precommit1c/tests/test_compile.py

@@ -0,0 +1,113 @@
+import unittest
+import pyv8unpack
+from os import path as path
+import os
+import tempfile
+import shutil
+from pathlib import Path
+import subprocess
+
+
+class TestV8Unpack(unittest.TestCase):
+    
+    def setUp(self):
+
+        unittest.TestCase.setUp(self)
+        self.tpath = tempfile.mkdtemp()
+        self.tfile = tempfile.mktemp()
+        
+        pathIb = path.join(path.curdir, ".git", "hooks", "ibService")
+        if (path.exists(pathIb)):
+            shutil.rmtree(pathIb)
+        shutil.copytree(path.join(path.curdir, "ibService"),
+            pathIb)
+        os.mkdir(path.join(path.curdir, ".git", "hooks", "v8Reader"))
+        shutil.copy(path.join(path.curdir, "v8Reader", "V8Reader.epf"),
+            path.join(path.curdir, ".git", "hooks", "v8Reader", "V8Reader.epf"))
+        
+    def tearDown(self):
+
+        if os.path.exists(self.tfile):
+            os.remove(self.tfile)
+        shutil.rmtree(self.tpath)
+        shutil.rmtree(path.join(path.curdir, ".git", "hooks", "ibService"))
+        os.remove(path.join(path.curdir, ".git", "hooks", "v8Reader", "V8Reader.epf"))
+        shutil.rmtree(path.join(path.curdir, ".git", "hooks", "v8Reader"))
+
+
+    def test_compile_from_source(self):
+        
+        self.tpath = tempfile.mkdtemp()
+        file = path.join(path.curdir, "tests", "Fixture.epf")
+        assert pyv8unpack.decompile([file], self.tpath)
+        tpath = path.join(self.tpath, "tests", "Fixture")
+        assert pyv8unpack.compilefromsource(tpath, self.tfile, "epf") == self.tfile
+        self.assertTrue(path.exists(self.tfile), "Собранный файл не существует {}".format(self.tfile))
+        
+
+    def test_decompile(self):
+        
+        self.tpath = tempfile.mkdtemp()
+        file = path.join(path.curdir, "tests", "Fixture.epf")
+        assert pyv8unpack.decompile([file], self.tpath)
+        
+    def test_decompile_checkfullpath(self):
+        
+        self.tpath = tempfile.mkdtemp()
+        file = path.join(path.curdir, "tests", "Fixture.epf")
+        assert pyv8unpack.decompile([file], self.tpath);
+
+
+class TestGitInit(unittest.TestCase):
+
+    def setUp(self):
+        unittest.TestCase.setUp(self)
+        self.tpath = tempfile.mkdtemp()
+        self.curdir = os.path.abspath(os.curdir);
+
+        print("cur dir {}, temp path {}".format(self.curdir, self.tpath))
+
+        os.chdir(self.tpath)
+        
+        try:
+            output = subprocess.check_output(['git','init', self.tpath]
+                ).decode("utf-8")
+        except subprocess.CalledProcessError:
+            print("Error diff files get: trace %s" % subprocess.CalledProcessError.output)
+
+        pathIb = path.join(self.tpath, ".git", "hooks", "ibService")
+        if (path.exists(pathIb)):
+            shutil.rmtree(pathIb)
+        shutil.copytree(path.join(self.curdir, "ibService"),
+            pathIb)
+        os.mkdir(path.join(self.tpath, ".git", "hooks", "v8Reader"))
+        shutil.copy(path.join(self.curdir, "v8Reader", "V8Reader.epf"),
+            path.join(self.tpath, ".git", "hooks", "v8Reader", "V8Reader.epf"))
+        shutil.copy(path.join(self.curdir,"pre-commit"), 
+        	path.join(self.tpath, ".git", "hooks", "pre-commit"))
+        shutil.copy(path.join(self.curdir,"pyv8unpack.py"), 
+        	path.join(self.tpath, ".git", "hooks", "pyv8unpack.py"))
+            
+
+    def tearDown(self):
+
+        #shutil.rmtree(self.tpath)
+        os.chdir(self.curdir)
+        print("cur dir {}".format(os.curdir))
+
+    def test_firstadd(self):
+        file = path.join(self.curdir, "tests", "Fixture.epf")    
+        shutil.copy(file,
+            path.join(self.tpath, "Fixture.epf"))
+
+
+        output = subprocess.check_output(['git','add', "-A", "."]
+                ).decode("utf-8")
+        print("output {}".format(output))
+        output = subprocess.check_output(['git','commit', "-m", "'init commit'"]
+                ).decode("utf-8")
+        print("output {}".format(output))
+
+        
+
+