Merge branch 'backup-cmd'

.gitignore

@@ -168,7 +168,6 @@ Generated_Code #added for RIA/Silverlight projects
 # Backup & report files from converting an old project file to a newer
 # Visual Studio version. Backup files are not needed, because we have git ;-)
 _UpgradeReport_Files/
-Backup*/
 UpgradeLog*.XML
 
 

scripts/CommandBuilders/CreateBackupCommandBuilder.py

@@ -0,0 +1,24 @@
+from commands.CreateBackupCommand import CreateBackupCommand
+from parser.BackupParser.CreateBackupParser import CreateBackupParser
+
+
+class CreateBackupCommandBuilder:
+	def __init__(self, pathProvider):
+		assert pathProvider is not None
+
+		self.__pathProvider = pathProvider
+
+	def isCreateBackup(self, line):
+		assert line is not None
+
+		parser = CreateBackupParser()
+		return parser.isValidLine(line)
+
+	def getCommandFor(self, line):
+		assert line is not None
+
+		parser = CreateBackupParser()
+		backupArguments = parser.parseLine(line)
+
+		command = CreateBackupCommand(self.__pathProvider, backupArguments)
+		return command

scripts/CommandBuilders/DeleteBackupCommandBuilder.py

@@ -0,0 +1,25 @@
+from commands.DeleteBackupCommand import DeleteBackupCommand
+from parser.BackupParser.DeleteBackupParser import DeleteBackupParser
+
+
+class DeleteBackupCommandBuilder:
+	def __init__(self, pathProvider):
+		assert pathProvider is not None
+		self.__pathProvider = pathProvider
+
+	def isDeleteBackup(self, line):
+		assert line is not None
+
+		parser = DeleteBackupParser()
+		isValid = parser.isValidLine(line)
+
+		return isValid
+
+	def getCommandFor(self, line):
+		assert line is not None
+
+		parser = DeleteBackupParser()
+		parser.parseLine(line)
+
+		command = DeleteBackupCommand(self.__pathProvider)
+		return command

scripts/CommandBuilders/RestoreBackupCommandBuilder.py

@@ -0,0 +1,25 @@
+from commands.RestoreBackupCommand import RestoreBackupCommand
+from parser.BackupParser.RestoreBackupParser import RestoreBackupParser
+
+
+class RestoreBackupCommandBuilder:
+	def __init__(self, pathProvider):
+		assert pathProvider is not None
+		self.__pathProvider = pathProvider
+
+	def isRestoreBackup(self, line):
+		assert line is not None
+
+		parser = RestoreBackupParser()
+		isValid = parser.isValidLine(line)
+
+		return isValid
+
+	def getCommandFor(self, line):
+		assert line is not None
+
+		parser = RestoreBackupParser()
+		parser.parseLine(line)
+
+		command = RestoreBackupCommand(self.__pathProvider)
+		return command

scripts/ManualTests/create_backup_test.py

@@ -0,0 +1,12 @@
+from CommandBuilders.CreateBackupCommandBuilder import CreateBackupCommandBuilder
+from ManualTests.path_provider import PathProvider
+
+line = "create backup for 'BuildSample'"
+
+baseDir = '../'
+path_provider = PathProvider(baseDir)
+
+cmdBuilder = CreateBackupCommandBuilder(path_provider)
+command = cmdBuilder.getCommandFor(line)
+
+command.execute()

scripts/ManualTests/delete_backup_test.py

@@ -0,0 +1,12 @@
+from CommandBuilders.DeleteBackupCommandBuilder import DeleteBackupCommandBuilder
+from ManualTests.path_provider import PathProvider
+
+line = "delete backup"
+
+baseDir = '../'
+path_provider = PathProvider(baseDir)
+
+cmdBuilder = DeleteBackupCommandBuilder(path_provider)
+command = cmdBuilder.getCommandFor(line)
+
+command.execute()

scripts/ManualTests/restore_backup_test.py

@@ -0,0 +1,15 @@
+from CommandBuilders.RestoreBackupCommandBuilder import RestoreBackupCommandBuilder
+from ManualTests.path_provider import PathProvider
+
+line = "restore from backup"
+
+baseDir = '../'
+path_provider = PathProvider(baseDir)
+
+builder = RestoreBackupCommandBuilder(path_provider)
+command = builder.getCommandFor(line)
+
+command.execute()
+
+
+

scripts/UnitTests/BackupParser/__init__.py

@@ -0,0 +1 @@
+__author__ = 'rzaitov'

scripts/UnitTests/BackupParser/test_createBackupParser.py

@@ -0,0 +1,13 @@
+import unittest
+from parser.BackupParser.CreateBackupParser import CreateBackupParser
+
+
+class TestCreateBackupParser(unittest.TestCase):
+	def setUp(self):
+		self.__parser = CreateBackupParser()
+
+	def test_validInput(self):
+		line = "create backup for 'SomeFolder'"
+		createBackupArgs = self.__parser.parseLine(line)
+
+		self.assertEqual('SomeFolder', createBackupArgs.folderName)

scripts/UnitTests/BackupParser/test_deleteBackupParser.py

@@ -0,0 +1,23 @@
+import unittest
+from parser.BackupParser.DeleteBackupParser import DeleteBackupParser
+
+
+class TestDeleteBackupParser(unittest.TestCase):
+	def setUp(self):
+		self.__parser = DeleteBackupParser()
+
+	def test_isValid(self):
+		line = 'delete backup'
+		isValid = self.__parser.isValidLine(line)
+
+		self.assertEqual(True, isValid)
+
+	def test_isNotValid(self):
+		line = 'bla backup'
+		isValid = self.__parser.isValidLine(line)
+
+		self.assertEqual(False, isValid)
+
+	def test_validInput(self):
+		line = 'delete backup'
+		self.__parser.parseLine(line)

scripts/UnitTests/BackupParser/test_restoreBackupParser.py

@@ -0,0 +1,11 @@
+import unittest
+from parser.BackupParser.RestoreBackupParser import RestoreBackupParser
+
+
+class TestRestoreBackupParser(unittest.TestCase):
+	def setUp(self):
+		self.__parser = RestoreBackupParser()
+
+	def test_ValidInput(self):
+		line = 'restore from backup'
+		self.__parser.parseLine(line)

scripts/commands/CreateBackupCommand.py

@@ -0,0 +1,16 @@
+import shutil
+
+class CreateBackupCommand:
+	def __init__(self, pathProvider, createBackupArguments):
+		assert pathProvider is not None
+		assert createBackupArguments is not None
+
+		self.__pathProvider = pathProvider
+		self.__createBackupArguments = createBackupArguments
+
+	def execute(self):
+		src = self.__pathProvider.resolveAbsPath(self.__createBackupArguments.getSourceFolderName())
+		dst = self.__pathProvider.resolveAbsPath(self.__createBackupArguments.getBackupFolderName())
+
+		shutil.rmtree(dst, ignore_errors=True)
+		shutil.copytree(src, dst, symlinks=False)

scripts/commands/DeleteBackupCommand.py

@@ -0,0 +1,15 @@
+import os
+import shutil
+
+class DeleteBackupCommand:
+	def __init__(self, pathProvider):
+		assert pathProvider is not None
+
+		self.__pathProvider = pathProvider
+
+	def execute(self):
+		baseDir = self.__pathProvider.resolveAbsPath('.')
+
+		dirs = [self.__pathProvider.resolveAbsPath(name) for name in os.listdir(baseDir) if os.path.isdir(os.path.join(baseDir, name)) & name.startswith('backup.')]
+		for dir in dirs:
+			shutil.rmtree(dir)

scripts/commands/RestoreBackupCommand.py

@@ -0,0 +1,22 @@
+import os
+import shutil
+
+
+class RestoreBackupCommand:
+	def __init__(self, pathProvider):
+		assert pathProvider is not None
+
+		self.__pathProvider = pathProvider
+
+	def execute(self):
+		baseDir = self.__pathProvider.resolveAbsPath('.')
+
+		dirPairs = [(name, "backup.{0}".format(name)) for name in os.listdir(baseDir) if os.path.isdir(self.__pathProvider.resolveAbsPath(name)) and not name.startswith('backup.')]
+
+		for pair in dirPairs:
+			absPair = (self.__pathProvider.resolveAbsPath(pair[0]), self.__pathProvider.resolveAbsPath(pair[1]))
+			if not os.path.exists(absPair[1]):
+				continue
+
+			shutil.rmtree(absPair[0])				# delete src
+			shutil.copytree(absPair[1], absPair[0])	# restore from backup

scripts/parser/BackupParser/CreateBackupArguments.py

@@ -0,0 +1,11 @@
+class CreateBackupArguments:
+	def __init__(self):
+		self.folderName = None
+
+	def getSourceFolderName(self):
+		return self.folderName
+
+	def getBackupFolderName(self):
+		return "backup.{0}".format(self.folderName)
+
+

scripts/parser/BackupParser/CreateBackupParser.py

@@ -0,0 +1,29 @@
+from parser.BackupParser.CreateBackupArguments import CreateBackupArguments
+from parser.LineParser import LineParser
+import re
+
+class CreateBackupParser(LineParser):
+	def __init__(self):
+		self.__createBackupArguments = CreateBackupArguments()
+
+	def parseLine(self, line):
+		assert line is not None
+
+		folderNameRegexp = r"'(?P<folder>[^']+)'$"
+
+		regexpSource = self.startsWithKeywordToken('create backup for') + folderNameRegexp
+		regexp = re.compile(regexpSource, re.UNICODE)
+
+		match = regexp.match(line)
+		self._guardMatch(match, line, regexpSource)
+
+		folderName = match.group('folder')
+		self.__createBackupArguments.folderName = folderName
+
+		return self.__createBackupArguments
+
+	def isValidLine(self, line):
+		assert line is not None
+
+		isValid = line.startswith('create backup')
+		return  isValid

scripts/parser/BackupParser/DeleteBackupParser.py

@@ -0,0 +1,18 @@
+from parser.LineParser import LineParser
+import re
+
+class DeleteBackupParser(LineParser):
+	def parseLine(self, line):
+		assert line is not None
+
+		regexpSource = r'delete backup\s*'
+		regexp = re.compile(regexpSource, re.UNICODE)
+
+		match = regexp.match(line)
+		self._guardMatch(match, line, regexpSource)
+
+	def isValidLine(self, line):
+		assert line is not None
+
+		isValid = line.startswith('delete backup')
+		return isValid

scripts/parser/BackupParser/RestoreBackupParser.py

@@ -0,0 +1,19 @@
+from parser.LineParser import LineParser
+import re
+
+
+class RestoreBackupParser(LineParser):
+	def parseLine(self, line):
+		assert line is not None
+
+		regexpSource = r'restore from backup\s*'
+		regexp = re.compile(regexpSource, re.UNICODE)
+
+		match = regexp.match(line)
+		self._guardMatch(match, line, regexpSource)
+
+	def isValidLine(self, line):
+		assert line is not None
+
+		isValid = line.startswith('restore from backup')
+

scripts/parser/BackupParser/__init__.py

@@ -0,0 +1 @@
+__author__ = 'rzaitov'

scripts/parser/CopyParser/CopyLineParser.py

@@ -24,14 +24,6 @@ class CopyLineParser(LineParser):
 		self.__copyArguments.setArguments(src, dst)
 		return self.__copyArguments
 
-	def keywordToken(self, keyword):
-		assert keyword is not None
-		return r'\s+' + keyword + r'\s+'
-
-	def startsWithKeywordToken(self, keyword):
-		assert keyword is not None
-		return r'^' + keyword + r'\s+'
-
 	def isValidLine(self, line):
 		assert line is not None
 

scripts/parser/LineParser.py

@@ -7,9 +7,17 @@ class LineParser:
 		assert line is not None
 		return False
 
+	def keywordToken(self, keyword):
+		assert keyword is not None
+		return r'\s+' + keyword + r'\s+'
+
+	def startsWithKeywordToken(self, keyword):
+		assert keyword is not None
+		return r'^' + keyword + r'\s+'
+
 	def _guardMatch(self, match_object, source, regexpSource = None):
 		if match_object is None:
-			msg = 'Recognition exception: {0} for {1}'.format(source, regexpSource)
+			msg = 'Recognition exception: "{0}" for "{1}"'.format(source, regexpSource)
 			raise Exception(msg)
 
 

scripts/run_manual_tests.py

@@ -1,3 +1,7 @@
 #import ManualTests.csproj_test
 #import ManualTests.info_plist_test
-import ManualTests.copy_test
+#import ManualTests.copy_test
+#import ManualTests.create_backup_test
+#import ManualTests.delete_backup_test
+
+import ManualTests.restore_backup_test