def test_add_heading_ids(self):
dialect = create_dialect(creole10_base, add_heading_ids=True)
parse = Parser(dialect)
self.assertEquals(
parse("== Level 2"),
'<h2 id="!level-2">Level 2</h2>\n')
self.assertEquals(
parse("= Level 1\n= Level 1"),
'<h1 id="!level-1">Level 1</h1>\n<h1 id="!level-1_1">Level 1</h1>\n')
self.assertEquals(
parse("= [[http://www.google.com|Google]]\n"),
"""<h1 id="!google"><a href="http://www.google.com">Google</a></h1>\n""")
self.assertEquals(
parse("== http://www.google.com\n"),
"""<h2 id="!http-www-google-com"><a href="http://www.google.com">http://www.google.com</a></h2>\n""")
self.assertEquals(
parse("== ~http://www.google.com\n"),
'<h2 id="!http-www-google-com">http://www.google.com</h2>\n')
self.assertEquals(
parse("[[foo bar#!a-heading_1]]"),
wrap_result("""<a href="foo_bar#!a-heading_1">foo bar#!a-heading_1</a>"""))
self.assertEquals(
parse("[[#!a-heading]]"),
wrap_result("""<a href="#!a-heading">#!a-heading</a>"""))
self.assertEquals(
parse("[[foo bar#1]]"),
wrap_result("""<a href="foo_bar%231">foo bar#1</a>"""))
self.assertEquals(
parse("[[#1]]"),
wrap_result("""<a href="%231">#1</a>"""))
dialect = create_dialect(creole10_base, add_heading_ids='')
parse = Parser(dialect)
self.assertEquals(
parse("== Level 2"),
'<h2 id="level-2">Level 2</h2>\n')
def run_tests():
vm = VirtualMachine()
test_files = sorted(os.listdir(test_dir))
for i, file_name in enumerate(test_files):
full_path = osp.join(test_dir, file_name)
print('>>> Run test #{} ({})'.format(i, file_name))
with open(full_path) as f:
text = f.read()
compiler = Compiler()
parser = Parser(Lexer(text))
ast = parser.parse()
# print(ast) # выведем дерево
program = compiler.compile(ast)
vars = vm.run(program)
print('Execution finished.')
for j in range(26):
if vars[j] != '$':
print('{} = {}'.format(chr(j + ord('a')), vars[j]))
print('\n' + '#' * 40 + '\n')
def main():
taskManager = TaskManager()
parser = Parser(taskManager=taskManager)
printWelcomeMessage()
while (True):
print("$ ", end="")
command = input()
if command == "":
continue
parser.processCommand(command)
def setUp(self):
def inter_wiki_link_maker(name):
return name[::-1]
def simple_class_maker(name):
return name.lower()
functions = {
'moo':inter_wiki_link_maker,
'goo':inter_wiki_link_maker,
}
base_urls = {
'goo': 'http://example.org',
'poo': 'http://example.org',
'Ohana': inter_wiki_url,
}
space_characters = {
'goo': '+',
'poo': '+',
}
class_functions = {
'moo':simple_class_maker,
'goo':simple_class_maker,
}
dialect = create_dialect(creole10_base,
interwiki_links_path_funcs=functions,
interwiki_links_class_funcs=class_functions,
interwiki_links_base_urls=base_urls,
interwiki_links_space_chars=space_characters
)
self.parse = Parser(dialect)
def setUp(self):
dialect = create_dialect(creole11_base,
wiki_links_base_url='http://creoleparser.x10hosting.com/cgi-bin/creolepiki/',
wiki_links_space_char='',
no_wiki_monospace=False,
macro_func=self.macroFactory)
self.parse = Parser(dialect)
def test_simple_tokens_option(self):
Base = creole10_base()
class MyDialect(Base):
simple_element = SimpleElement(token_dict={'*':'strong','#':'code'})
parse = Parser(MyDialect)
self.assertEquals(
parse("This block of #text *should* be monospace# now"),
wrap_result("This block of <code>text <strong>should</strong> be monospace</code> now"))
def setUp(self):
dialect = create_dialect(creole11_base,
wiki_links_base_url='',
wiki_links_space_char='_',
interwiki_links_base_urls={'Ohana': inter_wiki_url},
no_wiki_monospace=False,
macro_func=self.macroFactory)
self.parse = Parser(dialect)
def nextPage(next_page, number_page, headers, cookie, config, filename, regex):
p = Parser.Parser()
print("{YELLOW}\n+[PAGE %s/%s]-----------------------------------------+".
format(**colors) %
(next_page.split("&")[1].split("=")[1], number_page))
content_html = requestPage(next_page, headers, cookie)
p.getSearch(content_html.content, number_page, headers, cookie, config,
filename, regex)
def test_shutdown_game(self):
"""
shutdown_game should put the list active_players on game_info['kills']
should also clear the list active_players
should add one to the count of current_game
should call print_game()
"""
intersection = [{'Fulano': 56}, {'Deltrano': 1}, {'Jack': 0}]
active_players_mock = {
'2': ['Fulano', 56],
'6': ['Deltrano', 1],
'12': ['Jack', 0]
}
kills_mock = [{'Player1': 3}, {'Player2': 987}]
parser = Parser()
with mock.patch('core.Parser.print_game') as mockFunc:
parser.active_players = active_players_mock
parser.game_info['kills'] = kills_mock
parser.current_game = 11
parser.shutdown_game()
assert parser.current_game == 12
mockFunc.assert_called_once_with()
self.assertDictEqual(parser.game_info['kills'][2], intersection[0])
self.assertDictEqual(parser.game_info['kills'][3], intersection[1])
self.assertDictEqual(parser.game_info['kills'][4], intersection[2])
def setUp(self):
self.parse = Parser(
dialect=create_dialect(creole11_base,
wiki_links_base_url='',
interwiki_links_base_urls={'Ohana': inter_wiki_url},
#use_additions=True,
no_wiki_monospace=False
)
)
def test_blog_style_endings_option(self):
dialect = create_dialect(creole10_base, blog_style_endings=True)
parse = Parser(dialect)
self.assertEquals(
parse("The first line\nthis text **should** be on the second line\n now third"),
wrap_result("The first line<br />this text <strong>should</strong> be on the second line<br /> now third"))
self.assertEquals(
parse("The first line\\\\\nthis text **should** be on the second line\\\\\n now third"),
wrap_result("The first line<br />this text <strong>should</strong> be on the second line<br /> now third"))
def setUp(self):
creole2html = Parser(
dialect=create_dialect(creole10_base,
wiki_links_base_url=base_url,
interwiki_links_base_urls={'Ohana': inter_wiki_url},
#use_additions=False,
no_wiki_monospace=True,
)
)
self.parse = creole2html
def setUp(self):
dialect = create_dialect(creole11_base,
wiki_links_base_url='',
wiki_links_space_char='_',
interwiki_links_base_urls={'Ohana': inter_wiki_url},
no_wiki_monospace=False,
macro_func=self.macroFactory,
bodied_macros=dict(span=self.span, div=self.div),
non_bodied_macros=dict(luca=self.luca),
)
self.parse = Parser(dialect)
def test_disable_external_content(self):
dialect = create_dialect(creole10_base, disable_external_content=True)
parse = Parser(dialect)
self.assertEquals(
parse("{{campfire.jpg}}"),
wrap_result("""<img src="campfire.jpg" alt="campfire.jpg" title="campfire.jpg" />"""))
self.assertEquals(
parse("{{/campfire.jpg}}"),
wrap_result("""<span class="external_image">External images are disabled</span>"""))
self.assertEquals(
parse("{{http://www.somesite.com/campfire.jpg}}"),
wrap_result("""<span class="external_image">External images are disabled</span>"""))
def setUp(self):
noSpaces = Parser(
dialect=create_dialect(creole11_base,
wiki_links_base_url=base_url,
wiki_links_space_char='',
interwiki_links_base_urls={'Ohana': inter_wiki_url},
no_wiki_monospace=False,
wiki_links_class_func=class_name_function,
wiki_links_path_func=path_name_function
)
)
self.parse = noSpaces
def test_disable_images(self):
Base = creole10_base()
class MyDialect(Base):
@property
def inline_elements(self):
l = super(MyDialect,self).inline_elements
l.remove(self.img)
return l
parse = Parser(MyDialect)
self.assertEquals(
parse("{{somefile.jpg}}"),
wrap_result("{{somefile.jpg}}"))
def test_external_links_class_option(self):
dialect = create_dialect(creole10_base, external_links_class='external')
parse = Parser(dialect)
self.assertEquals(
parse("[[campfire.jpg]]"),
wrap_result("""<a href="campfire.jpg">campfire.jpg</a>"""))
self.assertEquals(
parse("[[/campfire.jpg]]"),
wrap_result("""<a class="external" href="/campfire.jpg">/campfire.jpg</a>"""))
self.assertEquals(
parse("[[http://www.somesite.com/campfire.jpg]]"),
wrap_result("""<a class="external" href="http://www.somesite.com/campfire.jpg">http://www.somesite.com/campfire.jpg</a>"""))
def test_log_splitter_wrong_log(self):
"""
log_splitter should not call any other function
if the received log is not on the correct format or
if the log does not match any of the predicted logs
"""
with mock.patch('core.Parser.init_game') as mockFunc1:
with mock.patch('core.Parser.shutdown_game') as mockFunc2:
with mock.patch('core.Parser.score_kill') as mockFunc3:
with mock.patch(
'core.Parser.userinfo_changed') as mockFunc4:
with mock.patch(
'core.Parser.client_begin') as mockFunc5:
with mock.patch('core.Parser.client_disconnect'
) as mockFunc6:
parser = Parser()
parser.log_splitter('blablabla anything')
parser.log_splitter('21:32 Item: whatever')
mockFunc1.assert_not_called()
mockFunc2.assert_not_called()
mockFunc3.assert_not_called()
mockFunc4.assert_not_called()
mockFunc5.assert_not_called()
mockFunc6.assert_not_called()
def __init__(self, parent = None):
Window.__init__(self,parent)
#Important must be empty this is a reference
self.files = []
self.recent = None
self.dirty = None
self.isFull = False
self.adb = Adb(self)
self.parser = Parser(self)
self.command = Command(self)
self.ant = Ant(self)
self.updater = update.Updater(self)
self.update()
def test_image_link_options(self):
dialect = create_dialect(creole10_base, wiki_links_base_url=['/pages/',
'/files/'],
wiki_links_space_char=['_',' '],
wiki_links_path_func=[lambda s:s.upper(),
lambda s:s.capitalize()])
parse = Parser(dialect)
self.assertEquals(
parse("[[foo bar]]"),
wrap_result("""<a href="/pages/FOO_BAR">foo bar</a>"""))
self.assertEquals(
parse("{{foo bar}}"),
wrap_result("""<img src="/files/Foo bar" alt="foo bar" title="foo bar" />"""))
def test_custom_markup_option(self):
def wikiword(mo, e):
return builder.tag.a(mo.group(1),href=mo.group(1))
dialect = create_dialect(creole10_base,
custom_markup=[('(c)','©'),
(re.compile(esc_neg_look + r'\b([A-Z]\w+[A-Z]+\w+)'),wikiword)])
parse = Parser(dialect)
self.assertEquals(
parse("The copyright symbol (c), escaped ~(c)"),
wrap_result("The copyright symbol ©, escaped (c)"))
self.assertEquals(
parse("A WikiPage name that is a ~WikiWord"),
wrap_result('A <a href="WikiPage">WikiPage</a> name that is a WikiWord'))
def test_interwiki_image_link_options(self):
dialect = create_dialect(creole10_base,
interwiki_links_base_urls={'a': ['/pages/','/files/']},
interwiki_links_space_chars={'a': ['_',' ']},
interwiki_links_path_funcs={'a': [lambda s:s.upper(),
lambda s:s.capitalize()]})
parse = Parser(dialect)
self.assertEquals(
parse("[[a:foo bar|Foo]]"),
wrap_result("""<a href="/pages/FOO_BAR">Foo</a>"""))
self.assertEquals(
parse("{{a:foo bar|Foo}}"),
wrap_result("""<img src="/files/Foo bar" alt="Foo" title="Foo" />"""))
def test_log_splitter(self):
"""
log_splitter should call the correct functions, with the
correct arguments depending on what is passed by as argument
"""
test_cases = [{
'path_name': 'init_game',
'log': '0:00 InitGame: the game has begun',
'argument': None
}, {
'path_name': 'shutdown_game',
'log': '78:32 ShutdownGame: game over',
'argument': None
}, {
'path_name': 'score_kill',
'log': '89:12 Kill: Somebody died!',
'argument': 'Somebody died!'
}, {
'path_name': 'userinfo_changed',
'log': '34:45 ClientUserinfoChanged: Some info has changed',
'argument': 'Some info has changed'
}, {
'path_name': 'client_disconnect',
'log': '58:62 ClientDisconnect: Fulano DC',
'argument': 'Fulano DC'
}, {
'path_name': 'client_begin',
'log': '58:62 ClientBegin: Fulano begin',
'argument': 'Fulano begin'
}]
parser = Parser()
for params in test_cases:
with mock.patch('core.Parser.' + params['path_name']) as mockFunc:
parser.log_splitter(params['log'])
if params['argument'] is None:
mockFunc.assert_called_with()
else:
mockFunc.assert_called_once_with(params['argument'])
def start(arg1, arg2):
pathToFile = arg1 #sys.argv[1]
pathToInputSettings = arg2 #sys.argv[2]
parser = Parser.Parser(pathToFile, pathToInputSettings)
if parser.parseNetwork():
network = parser.returnNetwork()
network.countTotalUnitCostPerPath()
settings = parser.returnSettings()
printSettings(settings)
populationSize = int(settings['population_size'])
probabOfCrossingover = float(settings['probab_of_crossingover'])
probabOfMutation = float(settings['probab_of_mutation'])
stopCriterion = settings['stop_criterion']
valueOfStopCriterion = int(settings['value_of_stop_criterion'])
seed = int(settings['seed'])
if settings['method'] == 'evolution':
isDAP = True if (settings['problem'] == 'DAP') else False
evo = Evolution.Evolution(isDAP, populationSize,
probabOfCrossingover, probabOfMutation,
seed, stopCriterion,
valueOfStopCriterion)
evo.createStartingPopulation(network)
evo.startEvolutionAlgorithm()
elif settings['method'] == 'bruteforce':
isDAP = True if (settings['problem'] == 'DAP') else False
bruteforce = BruteForce.BruteForce(network, isDAP)
bruteforce.startBruteforce()
# elif settings['method'] == 'bruteforce' and settings['problem'] == 'DDAP':
# bruteforce = BruteForce.BruteForce(network)
# bruteforce.generateAllPossibleSolutions()
# print(bruteforce.m_ListOfAllPossibleSolutions)
# # ddap = DDAP.DDAP(network, 100)
# # ddap.startBruteForceIterations()
else:
print("!!!!!!!!!!!!!!!!!!!!")
print("SOMETHING WENT WRONG")
print("!!!!!!!!!!!!!!!!!!!!")
print("BELOW CORECT INPUT FILE")
print(parser.exampleOfInputFile)
def test_score_kill(self):
"""
score_kill should give points to the player that killed
should take out one point if the player died from <world>
should increase the count of total kills
should increase the kill count of that death cause
"""
death_causes = [{
'death_cause': 0
}, {
'death_cause': 0
}, {
'death_cause': 0
}]
active_players_mock = {
'2': ['Fulano', 5],
'6': ['Deltrano', 1],
'12': ['Jack', 0]
}
parser = Parser()
parser.death_causes = death_causes
parser.active_players = active_players_mock
parser.game_info['total_kills'] = 6
# World kill
parser.score_kill('1022 2 0: something something')
assert parser.game_info['total_kills'] == 7
assert parser.active_players['2'][1] == 4
assert parser.death_causes[0]['death_cause'] == 1
# Player kill
parser.score_kill('6 12 2: something something')
assert parser.game_info['total_kills'] == 8
assert parser.active_players['6'][1] == 2
assert parser.death_causes[2]['death_cause'] == 1
def on_btnProcess_clicked(self):
"""
Slot documentation goes here.
"""
file = QtGui.QFileDialog.getSaveFileName(self, u"保存文件", '',
"Excel Files (*.%s)" % 'xls')
self.edSaveFile.setText(file)
self.edtStatus.append(u'开始执行....')
self.refresh()
config = self.CreateTaskConfig()
trans = Parser.TransactionControl(config)
r = trans.execute()
self.edtStatus.append(u'执行完成！')
resultFile = unicode(self.edSaveFile.text()).replace(r'/', r'//', 1)
print resultFile
self.edtStatus.append(u'统计结果导出到' + u'<a href="%s">%s</a>' %
(resultFile, resultFile) + '\n')
self.edtStatus.setOpenExternalLinks(True)
def test_init_game(self):
"""
init_game should rest game_info to be equal base_dict
"""
game_info_mock = {'item': 'some item', 'action': 'a random action'}
base_dict_mock = {
'word': 'the corresponding word',
'something': [],
'anotherThing': {}
}
parser = Parser()
parser.game_info = game_info_mock
parser.base_dict = base_dict_mock
parser.init_game()
assert parser.game_info == base_dict_mock
def test_bodied_macros_option(self):
def red(macro,e,*args,**kw):
return builder.tag.__getattr__(macro.isblock and 'div' or 'span')(
macro.parsed_body(),style='color:red')
red.parse_body = True
#return {'style':'color:red'}
def blockquote(macro,e,*args,**kw):
return builder.tag.blockquote(macro.parsed_body())
blockquote.parse_body = True
#return {'tag':'blockquote'}
MyDialect = create_dialect(creole11_base, bodied_macros=dict(red=red, blockquote=blockquote))
parse = Parser(MyDialect)
self.assertEquals(
parse("This block of <<red>>text **should** be monospace<</red>> now"),
wrap_result('This block of <span style="color:red">text <strong>should</strong> be monospace</span> now'))
self.assertEquals(
parse("<<red>>\ntext **should** be monospace\n<</red>>"),
'<div style="color:red"><p>text <strong>should</strong> be monospace</p>\n</div>')
self.assertEquals(
parse("This block of <<blockquote>>text **should** be monospace<</blockquote>> now"),
wrap_result('This block of </p><blockquote>text <strong>should</strong> be monospace</blockquote><p> now'))
self.assertEquals(
parse("<<blockquote>>\ntext **should** be monospace\n<</blockquote>>"),
'<blockquote><p>text <strong>should</strong> be monospace</p>\n</blockquote>')
def test_userinfo_changed(self):
"""
userinfo_changed should update the list of active players
"""
active_players_mock = {
'2': ['Fulano', 5],
'6': ['Deltrano', 1],
'12': ['Jack', 0]
}
game_info_players = ['Fulano', 'Deltrano', 'Jack']
parser = Parser()
parser.active_players = active_players_mock
parser.game_info['players'] = game_info_players
parser.userinfo_changed('4 n\\New Player\\whatever')
assert parser.active_players['4'] == ['New Player', 0]
def test_client_begin(self):
"""
client_begin should pass the confirmed active player to the list of players
"""
active_players_mock = {
'2': ['New Player', 0],
'6': ['Deltrano', 1],
'12': ['Jack', 0]
}
game_info_players = ['Fulano', 'Deltrano', 'Jack']
parser = Parser()
parser.active_players = active_players_mock
parser.game_info['players'] = game_info_players
parser.client_begin('2')
assert parser.game_info['players'][3] == 'New Player'
def test_client_disconnect(self):
"""
client_disconnect should pass the info from active_players to game_info['kills'] from the DC player
"""
kills_mock = [{'Player1': 3}, {'Player2': 987}]
active_players_mock = {
'2': ['New Player', 67],
'6': ['Deltrano', 1],
'12': ['Jack', 0]
}
parser = Parser()
parser.game_info['kills'] = kills_mock
parser.active_players = active_players_mock
parser.client_disconnect('6')
if '6' in parser.active_players:
assert False
else:
assert True
assert parser.game_info['kills'][2] == {'Deltrano': 1}
class MainWindow(Window):
def __init__(self, parent = None):
Window.__init__(self,parent)
#Important must be empty this is a reference
self.files = []
self.recent = None
self.dirty = None
self.isFull = False
self.adb = Adb(self)
self.parser = Parser(self)
self.command = Command(self)
self.ant = Ant(self)
self.updater = update.Updater(self)
self.update()
def update(self):
self.updater.start()
def init(self):
self.toolBar = Tool(self)
self.addToolBar(self.toolBar)
self.initConfig()
self.treeWidget.initProjects()
self.connect(self, SIGNAL('triggered()'), self.closeEvent)
self.connect(self.tabWidget,SIGNAL("dropped"), self.createTabs)
self.tabWidget.tabCloseRequested.connect(self.closeTab)
self.treeWidget.itemDoubleClicked.connect(self.treeItemClicked)
self.connect(self.treeWidget,SIGNAL("openFileClicked"),self.treeItemClicked)
self.connect(self.treeWidget,SIGNAL("sendFileClicked"),self.sendFile)
self.connect(self.treeWidget,SIGNAL("create"), lambda x:self.ant.create(x))
self.connect(self.treeWidget,SIGNAL("build"), lambda x:self.ant.build(x))
self.connect(self.treeWidget,SIGNAL("buildRun"), lambda x:self.ant.buildRun(x))
self.connect(self.treeWidget,SIGNAL("clean"), lambda x:self.ant.clean(x))
self.connect(self.treeWidget,SIGNAL("run"), lambda x:self.ant.run(x))
#self.initInterpreter()
def initConfig(self):
self.recent = config.recent()
self.dirty = []
if(config.files() != None):
if(len(config.files()) != 0):
for i in config.files():
self.createTab(i)
def treeItemClicked(self,item):
if(item.isFile()):
if(item.isDoc()):
self.createTab(item.getPath())
elif(item.isPic()):
self.openImage(item.getPath())
elif(item.isAudio()):
self.openAudio(item.getPath())
def sendFile(self,item):
if(item.isFile()):
self.command.setCmdText("adb push "+item.getPath()+" /sdcard/")
def initInterpreter(self):
self.ipy = PyInterp(self)
self.ipy.initInterpreter(locals())
self.outputTabWidget.addTab(self.ipy, "Python")
'''Must go through this only'''
def createTab(self,nfile):
if(nfile != None):
if(self.files != None):
if(len(self.files) != 0):
if(nfile in self.files):
#print "File Already Open\n"+nfile
self.tabWidget.setCurrentIndex(self.files.index(nfile))
return False
if(ospathexists(nfile)):
self.openEditor(nfile)
return True
else:
if(nfile in self.files):
self.files.remove(nfile)
config.setFile(self.files)
QMessageBox.about(self,"Can't Open","File Does Not Exist\n"+nfile)
return False
def createTabs(self,links):
if(links != None):
if(len(links) != 0):
for i in links:
self.createTab(i)
def openEditor(self,nfile):
text = ""
try:
infile = open(nfile, 'r')
tt = infile.read()
if(config.encoding() == Encoding.UNICODE):
text = unicode(tt,"utf-8")#must add utf-8 for it to work
else:
text = str(tt)
#infile.close()
self.files.append(nfile)
config.setFile(self.files)
self.dirty.append(False)
#print len(self.files)
tab = Editor(self,text,self.syntax(nfile),self.colorStyle)
self.tabWidget.addTab(tab,ospathbasename(nfile))
tab.textChanged.connect(lambda:self.setDirty(nfile))
if(self.files != None):
if(len(self.files)) != 0:
#This line sets the opened file to display first Important not checked
self.tabWidget.setCurrentIndex(len(self.files)-1)
return True
except:
if(nfile in self.files):
self.files.remove(nfile)
config.setFile(self.files)
QMessageBox.about(self,"Can't Open","File is Being Used\n"+nfile)
return False
finally:
if(infile != None):
infile.close()
def openImage(self,nfile):
if(ospathexists(nfile)):
form = Image(self,nfile)
form.show()
return True
else:
QMessageBox.about(self,"Can't Open","File Does Not Exist\n"+nfile)
return False
#print nfile
#self.tiler.addImage(nfile)
#self.tiler.show()
def openAudio(self,nfile):
if(ospathexists(nfile)):
form = Audio(self,nfile)
form.show()
return True
else:
QMessageBox.about(self,"Can't Open","File Does Not Exist\n"+nfile)
return False
def closeTab(self,index):
'''Boolean result invocation method.'''
done = True
if self.dirty[index]:
reply = QMessageBox.question(self,
"Sabel IDE - Unsaved Changes",
"Save unsaved changes?",
QMessageBox.Yes|QMessageBox.No|QMessageBox.Cancel)
if reply == QMessageBox.Cancel:
done = False
elif reply == QMessageBox.Yes:
done = self.fileSave(index)
elif reply == QMessageBox.No:
self.clearDirty(index)
done = True
if(done):
#print index
'''Must set the editor text to None to gc the memory used by text'''
self.files.remove(self.files[index])
config.setFile(self.files)
self.tabWidget.removeTab(index)
def setDirty(self,file):
'''On change of text in textEdit window, set the flag
"dirty" to True'''
index = self.files.index(file)
if self.dirty[index]:
return True
self.dirty[index] = True
flbase = ospathbasename(self.files[index])
self.tabWidget.setTabText(index,"*"+flbase)
def clearDirty(self,index):
'''Clear the dirty.'''
self.dirty[index] = False
flbase = ospathbasename(self.files[index])
self.tabWidget.setTabText(index,flbase)
def fileOpen(self):
fname = str(QFileDialog.getOpenFileName(self,"Open File", '.', "Files (*.*)"))
if not (fname == ""):
if self.files != None:
if len(self.files) != 0:
if(fname in self.files):
self.createTab(fname)
return True
else:
QMessageBox.about(self, "Already Open","File Already Open")
return False
else:
self.createTab(fname)
else:
self.files = []
self.createTab(fname)
def fileSave(self):
if(self.files != None):
if len(self.files) != 0:
index = self.tabWidget.currentIndex()
if not self.dirty[index]:
return
fname = self.files[index]
try:
fl = open(fname, 'w')
self.statusSaving()
self.progressStart()
if(config.encoding() == Encoding.UNICODE):
tempText = unicode(self.tabWidget.widget(index).text())
fl.write(tempText.encode("utf-8"))
fl.close()
else:
tempText = str(self.tabWidget.widget(index).text())
fl.write(tempText)
fl.close()
self.clearDirty(index)
except:
QMessageBox.about(self, "Can't Save","File is Locked")
self.statusWriting()
self.progressStop()
self.parser.run(self.files[index])
#must implement for all files
def fileSaveAll(self):
def fileSaveIndex(index):
if not self.dirty[index]:
return
fname = self.files[index]
try:
fl = open(fname, 'w')
self.statusSaving()
self.progressStart()
if(config.encoding() == Encoding.UNICODE):
tempText = unicode(self.tabWidget.widget(index).text())
fl.write(tempText.encode("utf-8"))
fl.close()
else:
tempText = str(self.tabWidget.widget(index).text())
fl.write(tempText)
fl.close()
self.clearDirty(index)
self.statusWriting()
self.progressStop()
except:
QMessageBox.about(self, "Can't Save","File is Locked")
if(self.files != None):
if len(self.files) != 0:
for file in self.files:
fileSaveIndex(self.files.index(file))
def closeEvent(self, event):
self.adb.close()
self.parser.close()
self.command.close()
self.ant.close()
notSaved = False
for files in self.dirty:
if files == True:
notSaved = True
if notSaved:
reply = QMessageBox.question(self,
"Sabel - Unsaved Changes",
"Save unsaved changes?",
QMessageBox.Yes|QMessageBox.No|QMessageBox.Cancel)
if reply == QMessageBox.Cancel:
return
elif reply == QMessageBox.Yes:
self.fileSaveAll()
sys.exit()
def syntax(self,nfile):
lang = 0
if nfile.endswith(".py"):
lang = 0
elif (nfile.endswith(".cpp") or nfile.endswith(".h") or nfile.endswith(".c") or nfile.endswith(".hpp")):
lang = 1
elif nfile.endswith(".nut"):
lang = 2
elif nfile.endswith(".neko"):
lang = 2
return lang
from core import Parser, Config
if __name__ == '__main__':
config = Config('Config.xml')
parser = Parser(config)
t = parser.parse('http://www.imdb.com/title/tt2312718/?ref_=nm_flmg_act_6')
for genre in t.genres:
print(genre.name)
import core.Logs as Logs
import core.Parser as Parser
import core.Time_lib as Time_lib
import core.Config as Config
import core.Html_writer as Html
try:
output_data = {}
Logs.add_log(Config.SEPARATOR + "Program started.")
configs = Config.load_config()
output_data[configs[0]["prefix"]] = Parser.parse(configs[1], configs[0]) # Сохранение данных для каждого сайта
Html.write_html(output_data[configs[0]["prefix"]], configs[0])
Logs.add_log("Program finished. Time: " + Time_lib.time_from_start() + Config.SEPARATOR)
except:
Logs.add_log("Unknown error.")
class MacroTest(unittest.TestCase, BaseTest):
"""
"""
def setUp(self):
dialect = create_dialect(
wiki_links_base_url='http://creoleparser.x10hosting.com/cgi-bin/creolepiki/',
wiki_links_space_char='',
use_additions=True,
no_wiki_monospace=False,
macro_func=self.macroFactory)
self.parse = Parser(dialect)
class Wiki(object):
page_title='Home'
def getFragment(self, text):
wrapped = Markup(text)
fragment = builder.tag(wrapped)
return fragment
def getStream(self, text):
wrapped = Markup(text)
fragment = builder.tag(wrapped)
return fragment.generate()
def macroFactory(self, macro_name, arg_string, body, context,wiki):
if macro_name == 'html':
return self.getFragment(body)
elif macro_name == 'title':
return wiki.page_title
elif macro_name == 'span':
return builder.tag.span(self.parse.generate(body,context='inline'),id_=arg_string.strip())
elif macro_name == 'div':
return builder.tag.div(self.parse.generate(body),id_=arg_string.strip())
elif macro_name == 'html2':
return Markup(body)
elif macro_name == 'htmlblock':
return self.getStream(body)
elif macro_name == 'pre':
return builder.tag.pre('**' + body + '**')
elif macro_name == 'steve':
return '**' + arg_string + '**'
elif macro_name == 'luca':
return builder.tag.strong(arg_string)
elif macro_name == 'mateo':
return builder.tag.em(body)
elif macro_name == 'ReverseFrag':
return builder.tag(body[::-1])
elif macro_name == 'Reverse':
return body[::-1]
elif macro_name == 'Reverse-it':
return body[::-1]
elif macro_name == 'ReverseIt':
return body[::-1]
elif macro_name == 'lib.ReverseIt-now':
return body[::-1]
elif macro_name == 'ifloggedin':
return body
elif macro_name == 'username':
return 'Joe Blow'
elif macro_name == 'center':
return builder.tag.span(body, class_='centered')
elif macro_name == 'footer':
return '<<center>>This is a footer.<</center>>'
elif macro_name == 'footer2':
return '<<center>>\nThis is a footer.\n<</center>>'
elif macro_name == 'reverse-lines':
if body is not None:
l = reversed(body.rstrip().split('\n'))
if arg_string.strip() == 'output=wiki':
return '\n'.join(l) + '\n'
else:
return builder.tag('\n'.join(l) + '\n')
def test_macros(self):
self.assertEquals(
self.parse('<<title>>',environ=self.Wiki),
wrap_result('Home'))
self.assertEquals(
self.parse('<<html>><q cite="http://example.org">foo</q><</html>>'),
wrap_result('<q cite="http://example.org">foo</q>'))
self.assertEquals(
self.parse('<<html2>><b>hello</b><</html2>>'),
'<b>hello</b>\n')
self.assertEquals(
self.parse('<<htmlblock>><q cite="http://example.org">foo</q><</htmlblock>>'),
'<q cite="http://example.org">foo</q>\n')
self.assertEquals(
self.parse('<<pre>>//no wiki//<</pre>>'),
'<pre>**//no wiki//**</pre>\n')
self.assertEquals(
self.parse('<<pre>>one<</pre>>\n<<pre>>two<</pre>>'),
'<pre>**one**</pre>\n<pre>**two**</pre>\n')
self.assertEquals(
self.parse('<<pre>>one<<pre>>\n<</pre>>two<</pre>>'),
'<pre>**one<<pre>>\n<</pre>>two**</pre>\n')
self.assertEquals(
self.parse(u'<<mateo>>fooɤ<</mateo>>'),
wrap_result('<em>foo\xc9\xa4</em>'))
self.assertEquals(
self.parse(u'<<steve fooɤ>>'),
wrap_result('<strong> foo\xc9\xa4</strong>'))
self.assertEquals(
self.parse('<<ReverseFrag>>**foo**<</ReverseFrag>>'),
wrap_result('**oof**'))
self.assertEquals(
self.parse('<<Reverse>>**foo**<</Reverse>>'),
wrap_result('<strong>oof</strong>'))
self.assertEquals(
self.parse('<<Reverse>>foo<</Reverse>>'),
wrap_result('oof'))
self.assertEquals(
self.parse('<<Reverse-it>>foo<</Reverse-it>>'),
wrap_result('oof'))
self.assertEquals(
self.parse('<<ReverseIt>>foo<</ReverseIt>>'),
wrap_result('oof'))
self.assertEquals(
self.parse('<<lib.ReverseIt-now>>foo<</lib.ReverseIt-now>>'),
wrap_result('oof'))
self.assertEquals(
self.parse(u'<<luca boo>>foo<</unknown>>'),
wrap_result('<strong> boo</strong>foo<</unknown>>'))
self.assertEquals(
self.parse('Hello<<ifloggedin>> <<username>><</ifloggedin>>!'),
wrap_result('Hello Joe Blow!'))
self.assertEquals(
self.parse(' <<footer>>'),
wrap_result(' <span class="centered">This is a footer.</span>'))
self.assertEquals(
self.parse('<<footer2>>'),
'<p><span class="centered">\nThis is a footer.\n</span></p>\n')
self.assertEquals(
self.parse('<<luca foobar>>'),
'<p><strong> foobar</strong></p>\n')
self.assertEquals(
self.parse("<<reverse-lines>>one<</reverse-lines>>"),
wrap_result("one\n"))
self.assertEquals(
self.parse("<<reverse-lines>>one\ntwo\n<</reverse-lines>>"),
wrap_result("two\none\n"))
self.assertEquals(
self.parse("<<reverse-lines>>\none\ntwo<</reverse-lines>>"),
wrap_result("two\none\n\n"))
self.assertEquals(
self.parse(
"""\
<<reverse-lines>>
one
two
<</reverse-lines>>
"""),
"""\
<p>two
one
</p>""")
self.assertEquals(
self.parse(u"\n<<div one>>\nblaa<</div>>"),
'<div id="one"><p>blaa</p>\n</div>\n')
self.assertEquals(
self.parse("<<reverse-lines>>one\n{{{two}}}\n<</reverse-lines>>"),
wrap_result("{{{two}}}\none\n"))
self.assertEquals(
self.parse("<<reverse-lines>>one\n{{{\ntwo}}}\n<</reverse-lines>>"),
wrap_result("two}}}\n{{{\none\n"))
self.assertEquals(
self.parse("<<reverse-lines>>one\n{{{\ntwo\n}}}<</reverse-lines>>"),
wrap_result("}}}\ntwo\n{{{\none\n"))
self.assertEquals(
self.parse("<<reverse-lines>>\none\n{{{\ntwo\n}}}\n<</reverse-lines>>"),
"<p>}}}\ntwo\n{{{\none\n</p>")
self.assertEquals(
self.parse("<<reverse-lines output=wiki>>one\n{{{\ntwo\n}}}<</reverse-lines>>"),
wrap_result("}}}\ntwo\n{{{\none\n"))
self.assertEquals(
self.parse("<<reverse-lines output=wiki>>one\n}}}\ntwo\n{{{<</reverse-lines>>"),
wrap_result("<span>\ntwo\n</span>\none\n"))
self.assertEquals(
self.parse("<<reverse-lines output=wiki>>one\n}}}\ntwo\n{{{\n<</reverse-lines>>"),
wrap_result("<span>\ntwo\n</span>\none\n"))
self.assertEquals(
self.parse("<<reverse-lines output=wiki>>\none\n}}}\n\ntwo\n{{{\n<</reverse-lines>>"),
"<pre>two\n\n</pre>\n<p>one</p>\n")
self.assertEquals(
self.parse("<<reverse-lines output=wiki>>\none\n\n}}}\ntwo\n{{{\n<</reverse-lines>>"),
"<pre>two\n</pre>\n<p>one</p>\n")
def test_nesting_macros(self):
self.assertEquals(
self.parse('<<span one>>part 1<</span>><<span two>>part 2<</span>>'),
wrap_result('<span id="one">part 1</span><span id="two">part 2</span>'))
self.assertEquals(
self.parse('<<span>>part 1a<<span two>>part 2<</span>>part 1b<</span>>'),
wrap_result('<span id="">part 1a<span id="two">part 2</span>part 1b</span>'))
self.assertEquals(
self.parse('<<span>>part 1a<<span>>part 2<</span>>part 1b<</span>>'),
wrap_result('<span id="">part 1a<span id="">part 2</span>part 1b</span>'))
self.assertEquals(
self.parse('<<span one>>part 1a<<span two>>part 2<</span>>part 1b<</span>>'),
wrap_result('<span id="one">part 1a<span id="two">part 2</span>part 1b</span>'))
self.assertEquals(
self.parse("""
<<div one>>
part 1a
<<div two>>
part 2
<</div>>
part 1b
<</div>>"""),'<div id="one"><p>part 1a</p>\n<div id="two"><p>part 2</p>\n</div><p>part 1b</p>\n</div>')
self.assertEquals(
self.parse("""
<<div one>>
part 1
<</div>>
<<div one>>
part 2
<</div>>"""),'<div id="one"><p>part 1</p>\n</div><div id="one"><p>part 2</p>\n</div>')
def test_links(self):
self.assertEquals(
self.parse("http://www.google.com"),
wrap_result("""<a href="http://www.google.com">http://www.google.com</a>"""))
self.assertEquals(
self.parse("~http://www.google.com"),
wrap_result("""http://www.google.com"""))
self.assertEquals(
self.parse("[[http://www.google.com]]"),
wrap_result("""<a href="http://www.google.com">http://www.google.com</a>"""))
self.assertEquals(
self.parse("[[http://www.google.com| <<luca Google>>]]"),
wrap_result("""<a href="http://www.google.com"><strong> Google</strong></a>"""))
def test_links_with_spaces(self):
self.assertEquals(
self.parse("[[This Page Here]] is <<steve the steve macro!>>"),
wrap_result("""<a href="http://creoleparser.x10hosting.com/cgi-bin/creolepiki/ThisPageHere">This Page Here</a> is <strong> the steve macro!</strong>"""))
self.assertEquals(
self.parse("[[New Page|this]]"),
wrap_result("""<a href="http://creoleparser.x10hosting.com/cgi-bin/creolepiki/NewPage">this</a>"""))
def test_print_game(self):
"""
print_game should get the top player of the match
should get the deaths by cause
should dump all the game info into game_json
"""
game_info_mock = {
'total_kills': 34,
'players': ['Fulano', 'Player1', 'Player2'],
'kills': [{
'Player1': 3
}, {
'Player2': 12
}, {
'Fulano': 6
}],
'kills_by_means': {}
}
death_causes_mock = [{
'death_cause0': 6
}, {
'death_cause1': 0
}, {
'death_cause2': 28
}]
death_causes_base_mock = [{
'death_cause0': 0
}, {
'death_cause1': 0
}, {
'death_cause2': 0
}]
cheat_sheet = {
'total_kills': 34,
'players': ['Fulano', 'Player1', 'Player2'],
'kills': [{
'Player1': 3
}, {
'Player2': 12
}, {
'Fulano': 6
}],
'kills_by_means': {
'death_cause0': 6,
'death_cause2': 28
},
'top_player': 'Player2'
}
parser = Parser()
parser.game_info = game_info_mock
parser.death_causes = death_causes_mock
parser.current_game = 15
parser.print_game()
assert parser.death_causes == death_causes_base_mock
assert parser.game_json['game-15'] == cheat_sheet
