def test_receives_repeated_normal_CR_LF_in_broken_godwars_mode_fine(self):
self.tc.fix_broken_godwars_line_endings = True
self.tc.dataReceived("foo\r\n\r\n")
expected = [
simpleml("foo", fg_code(WHITE, False), bg_code(BLACK)),
simpleml("", fg_code(WHITE, False), bg_code(BLACK))
]
for ml in expected:
ml.wrap = True
lines = [
line
for ((line, ), kwargs) in self.e.metalineReceived.call_args_list
]
assert lines == expected, lines
def prompt_time_display(match, realm):
"""Add a pink coloured timestamp to the prompt."""
now = datetime.now()
metaline = simpleml(
(now.strftime("(%H:%M:%S.%%s) ") % str(now.microsecond)[:2]),
HexFGCode(0xFF, 0xA0, 0xA0), bg_code(BLACK))
realm.alterer.insert_metaline(match.end(1), metaline)
def write(self, line, soft_line_start=False):
"""Write a line to the screen.
This forcibly converts its argument to a Metaline.
"""
if not isinstance(line, (basestring, Metaline)):
line = str(line)
if isinstance(line, basestring):
metaline = simpleml(line, fg_code(WHITE, False), bg_code(BLACK))
metaline.wrap = False
metaline.soft_line_start = soft_line_start
else:
metaline = line
#we don't need to close off the ends of the note, because thanks to
#the magic of the ColourCodeParser, each new line is started by the
#implied colour, so notes can't bleed out into text (though the
#reverse can be true).
#this needs to be before the futzing with NLs and GA, because textwrap
#obliterates all other newlines.
metaline = metaline.wrapped(self.wrapper)
#we don't actually append newlines at the end, but the start. This
#simplifies things, because we don't use a newline where a soft line
#end meets a soft line start, so there's only one place in this code
#that can add newlines.
if self._last_line_end is not None:
if self._last_line_end == 'hard' or not metaline.soft_line_start:
metaline.insert(0, '\n')
for prot in self.protocols:
prot.metalineReceived(metaline)
self._last_line_end = metaline.line_end
def test_insert_metaline():
ml_one = Metaline('foo baz', RunLengthList([(0, 'foo'), (4, 'baz')]),
RunLengthList([(0, 'foo'), (4, 'baz')]))
ml_two = simpleml('bar ', 'bar', 'bar')
ml_one.insert_metaline(4, ml_two)
assert ml_one == Metaline(
"foo bar baz", RunLengthList([(0, 'foo'), (4, 'bar'), (8, 'baz')]),
RunLengthList([(0, 'foo'), (4, 'bar'), (8, 'baz')]))
def test_fixes_LF_CR_normally(self):
self.tc.fix_broken_godwars_line_endings = True
self.tc.dataReceived("foo\n\r")
expected = [simpleml("foo", fg_code(WHITE, False), bg_code(BLACK))]
expected[0].wrap = True
lines = [
line
for ((line, ), kwargs) in self.e.metalineReceived.call_args_list
]
assert lines == expected, lines
def test_no_tell_sent_doesnt_cock_up(self):
ml = simpleml('Bar tells you, "Blah."', fg_code(WHITE, False),
bg_code(BLACK))
self.fact.realm.metalineReceived(ml)
ml_written = self.p.metalineReceived.call_args[0][0]
colour_expecting = ml_written.fores.get_at(0)
self.fact.realm.send("tell baz blah")
ml = simpleml("Whom do you wish to tell to?", fg_code(WHITE, False),
bg_code(BLACK))
self.fact.realm.metalineReceived(ml)
self.fact.realm.send("tell bar blah")
ml = simpleml('You tell Bar, "Blah."', fg_code(WHITE, False),
bg_code(BLACK))
self.fact.realm.metalineReceived(ml)
ml_written_2 = self.p.metalineReceived.call_args[0][0]
assert ml_written_2.fores.get_at(10) == colour_expecting
def connectionMade(self):
"""The MUD's been connected to."""
message = time.strftime("Connection opened at %H:%M:%S.")
colour = HexFGCode(0xFF, 0xAA, 0x00) #lovely orange
metaline = simpleml(message, colour, bg_code(BLACK))
self.write(metaline)
for prot in self.protocols:
prot.connectionMade()
self.telnet.msdp.add_listener(self.mmap)
def obj_as_metaline(self, o):
desc = self.objs[o]
print desc.keys()
colour = HexFGCode(0xFF, 0xAA, 0x00)
metaline = simpleml('(', colour, bg_code(BLACK))
metaline += simpleml(desc['type'], colour, bg_code(BLACK))
if desc['weapon'] and desc['weapon'] != 'None':
metaline += simpleml(',' + desc['weapon'], fg_code(YELLOW, True), bg_code(BLACK))
metaline += simpleml(',' + desc['dmg_str'], fg_code(RED, True), bg_code(BLACK))
metaline += simpleml(',' + '%s' % desc['dmg_avg'], fg_code(RED, True), bg_code(BLACK))
if desc['ac']:
metaline += simpleml(',AC:%s' % desc['ac'], fg_code(RED, True), bg_code(BLACK))
if desc['prop'] != '':
metaline += simpleml(',' + desc['prop'], fg_code(BLUE, True), bg_code(BLACK))
metaline += simpleml(')', colour, bg_code(BLACK))
return metaline
def connectionLost(self):
"""The link to the MUD died.
It is guaranteed that this will be called before close on connection
event receivers.
"""
message = time.strftime("Connection closed at %H:%M:%S.")
colour = HexFGCode(0xFF, 0xAA, 0x00) #lovely orange
metaline = simpleml(message, colour, bg_code(BLACK))
self.write(metaline)
for prot in self.protocols:
prot.connectionLost()
#we might be waiting on the connection to die before we send out
#close events
if self._closing_down:
for prot in self.protocols:
prot.close()
self._closing_down = True
self.mmap.save()
def anyline(self, match, realm):
if self.opozn_flag:
s = match.group(1).strip()
if s != '':
self.obj_desc = '%s\n%s' % (self.obj_desc, s)
if self.parse_flag:
# logging baz
m = RE_BAZ_NEW.match(match.group(1))
print m, match.group(1)
if m:
w = {
'lot': m.group(1).strip(),
'object': m.group(2).strip(),
'price': m.group(3).strip(),
'date': '%s' % datetime.datetime.now(),
}
self.baz_log.write('%s\n' % json.dumps(w, encoding="utf-8"))
self.baz_log.flush()
print 'PPPPP', match.group(1).strip()
for res in OBJ_RES:
m = res.match(match.group(1))
if m:
o = m.group(1).strip()
if not self.has_obj(o):
print 'Getting from mudportal'
desc = self.get_from_mudportal(o)
if desc != {}:
self.update_obj(o, desc)
print o
if self.has_obj(o):
realm.alterer.insert_metaline(m.start(1) + len(o) + 1, self.obj_as_metaline(o))
else:
metaline = simpleml('(?)', fg_code(RED, True), bg_code(BLACK))
realm.alterer.insert_metaline(m.start(1) + len(o) + 1, metaline)
def test_metalineReceived_doesnt_change_colour_if_not_needed(self):
self.o.change_colour = Mock()
self.o.metalineReceived(simpleml("foo", self.o.fore, self.o.back))
assert not self.o.change_colour.called
def test_metalineReceived_changes_colour_if_needed(self):
self.o.metalineReceived(simpleml("foo", self.f1, self.b1))
print self.o.method_calls
assert self.o.method_calls == [("change_colour", (), {}),
("write_out_span", ("foo", ), {})]
def test_metalineReceived_calls_write_out_span(self):
self.o.write_out_span = Mock()
self.o.metalineReceived(simpleml("foo", self.o.fore, self.o.back))
assert self.o.write_out_span.call_args_list == [(("foo", ), {})]
def test_Metaline_addition_normal():
res = simpleml("foo", sentinel.fore, sentinel.back) + \
simpleml("bar", sentinel.fore2, sentinel.back2)
assert res.line == "foobar", res.line
assert res.fores.items() == [(0, sentinel.fore), (3, sentinel.fore2)]
assert res.backs.items() == [(0, sentinel.back), (3, sentinel.back2)]
def test_insert_then_insert_metaline_bumps(self):
self.la.insert(1, 'foo')
self.la.insert_metaline(2, simpleml('bar', 'bar', 'bar'))
res = self.la.apply(simpleml('baz', None, None))
assert res.line == "bfooabarz", res.line
def test_insert_metaline_then_insert_bumps(self):
ml_ins = simpleml('foo', 'foo', 'foo')
self.la.insert_metaline(1, ml_ins)
self.la.insert(2, 'baz')
res = self.la.apply(simpleml('bar', 'bar', 'bar'))
assert res.line == 'bfooabazr', res.line
def test_Metaline_addition_first_has_trailling_colours():
ml = simpleml("foo", sentinel.foofore, sentinel.fooback)
ml.change_fore(0, 4, sentinel.foofore2)
res = ml + simpleml("bar", sentinel.barfore, sentinel.barback)
assert res.fores.items() == [(0, sentinel.foofore2),
(3, sentinel.barfore)], res.fores.items()
def ml(m, c):
return simpleml(m, c, bg_code(BLACK))
def test_Metaline_insert_at_0_doesnt_leave_start_uncoloured():
ml = simpleml('foo', sentinel.fore, sentinel.back)
ml.insert(0, 'bar')
assert ml.fores.items() == [(0, sentinel.fore)]
assert ml.backs.items() == [(0, sentinel.back)]
def test_simpleml_creates_equivalent_metaline():
ml = simpleml("foo", sentinel.fore, sentinel.back)
assert ml == Metaline("foo", RunLengthList([(0, sentinel.fore)]),
RunLengthList([(0, sentinel.back)]))
def info(self, message, colour=HexFGCode(0xFF, 0xAA, 0x00)):
metaline = simpleml(message, colour, bg_code(BLACK))
self.write(metaline)
def test_insert_metaline_tidies_when_inserted_at_end():
res = simpleml("foo", sentinel.foofore, sentinel.fooback) + \
simpleml("bar", sentinel.barfore, sentinel.barback)
assert res.fores.items() == [(0, sentinel.foofore), (3, sentinel.barfore)]
assert res.backs.items() == [(0, sentinel.fooback), (3, sentinel.barback)]
