def test_change_camera(self):
db = Database()
db.append_person('taro', '太郎', '', 15, (1, 1), 'm', 'student')
scmd = cmd.StoryCmd(db)
data = [
# (key, expect)
(True, 'taro', '太郎'),
]
def checker(key, expect):
tmp = scmd.change_camera(key)
self.assertIsInstance(tmp, SCode)
self.assertEqual(tmp.cmd, SCmd.CHANGE_CAMEARA)
self.assertEqual(tmp.src.name, expect)
validate_with_fail(self, 'change_camera', checker, data)
def test_change_stage(self):
db = Database()
db.append_stage('room', '部屋')
scmd = cmd.StoryCmd(db)
data = [
# (key, expect)
(True, 'room', '部屋'),
]
def checker(key, expect):
tmp = scmd.change_stage(key)
self.assertIsInstance(tmp, SCode)
self.assertEqual(tmp.cmd, SCmd.CHANGE_STAGE)
self.assertEqual(tmp.src.name, expect)
validate_with_fail(self, 'change_stage', checker, data)
def test_change_time(self):
import datetime
db = Database()
db.append_time('t1', 'noon', 12, 00)
scmd = cmd.StoryCmd(db)
data = [
# (keys, expect, exp_time)
(True, ('t1', ), 'noon', datetime.time(12, 00)),
(True, (11, 00), '', datetime.time(11, 00)),
]
def checker(keys, expect, exp_time):
tmp = scmd.change_time(*keys)
self.assertIsInstance(tmp, SCode)
self.assertEqual(tmp.cmd, SCmd.CHANGE_TIME)
self.assertEqual(tmp.src.name, expect)
self.assertEqual(tmp.src.time, exp_time)
validate_with_fail(self, 'change_time', checker, data)
def test_change_day(self):
import datetime
db = Database()
db.append_day('d1', 'day1', 1, 1, 2020)
scmd = cmd.StoryCmd(db)
data = [
# (keys, expect, exp_date)
(True, ('d1', ), 'day1', datetime.date(2020, 1, 1)),
(True, (2, 2, 1000), '', datetime.date(1000, 2, 2)),
]
def checker(keys, expect, exp_date):
tmp = scmd.change_date(*keys)
self.assertIsInstance(tmp, SCode)
self.assertEqual(tmp.cmd, SCmd.CHANGE_DATE)
self.assertEqual(tmp.src.name, expect)
self.assertEqual(tmp.src.date, exp_date)
validate_with_fail(self, 'change_date', checker, data)
def execute(
self,
src: Story,
config: StoryConfig,
db: Database,
) -> ResultData: # pragma: no cover
''' Exec story building, compiling and outputting.
NOTE: Compile option
1. normal: output `story.md`
2. plot: output `plot.md`
3. text: output `story.txt`
4. scenario: output `sc_story.md`
'''
LOG.info('RUN: == START EXEC ==')
LOG.info('RUN: START-PHASE: Preparation')
tmp = assertion.is_instance(src, Story)
is_succeeded = True
result = None
error = None
is_succeeded = self._build_options(config)
if not is_succeeded:
msg = 'Cannot build option arguments!!'
error = RunnerError(msg)
LOG.error(msg)
return ResultData([], is_succeeded, error)
LOG.info('... SUCCESS: Preparation')
LOG.info('RUN: START-PHASE: Pre-Compile')
result = self._pre_compile(src, config, db)
if not result.is_succeeded:
return result
tmp = assertion.is_instance(result.data, Story)
LOG.info('... SUCCESS: Finish: Pre-Compile')
LOG.info('RUN: START-PHASE: Compile and Output')
result = assertion.is_instance(self._compile(tmp, config, db),
ResultData)
LOG.info('... SUCCESS: Finish: Compile and Output')
self._output_storyinfo(config)
LOG.info('RUN: analyzer check')
if self._is_analyzed:
result = assertion.is_instance(
self._analyze_and_output(tmp, db.get_person_names(),
self._is_debug), ResultData)
LOG.info('RUN: == ALL SUCCEEDED ==')
return result
def test_scene(self):
scmd = cmd.StoryCmd(Database())
data = [
# (title, args, outline, expect)
(True, 'test', ('a', 'b'), 'apple', 'test'),
]
def checker(title, args, outline, expect):
tmp = scmd.scene(title, *args, outline=outline)
self.assertIsInstance(tmp, Scene)
self.assertEqual(tmp.title, expect)
validate_with_fail(self, 'scene', checker, data)
def __init__(self, title: str, loglevel: str=__DEFAULT_LOG_LEVEL__):
# log
LOG.set_level(loglevel)
# start logging
LOG.info('--------' * 4 + f' START LOGGING [{LOG.level}]' + '--------' * 4)
LOG.info('CLASS: World: initialize')
LOG.debug(f'-- title: {title}')
# data
self._config = StoryConfig(title)
self._db = Database()
# command
self._cmd = StoryCmd(self._db)
self._tag = TagCmd()
# hook method
self.chapter = self._cmd.chapter
self.episode = self._cmd.episode
self.scene = self._cmd.scene
self.plot_note = self._cmd.plot_note
self.foreshadow = self._cmd.foreshadow
self.payoff = self._cmd.payoff
self.motif = self._cmd.motif
self.plot_setup = self._cmd.plot_setup
self.plot_develop = self._cmd.plot_develop
self.plot_resolve = self._cmd.plot_resolve
self.plot_turnpoint = self._cmd.plot_turnpoint
self.writer_note = self._cmd.writer_note
self.chara_note = self._cmd.character_note
self.document = self._cmd.document
self.br = self._tag.br
self.comment = self._tag.comment
self.symbol = self._tag.symbol
self._config.set_log_level(loglevel)
self.change_camera = self.cmd.change_camera
self.change_stage = self.cmd.change_stage
self.change_date = self.cmd.change_date
self.change_time = self.cmd.change_time
class World(object):
''' Story World Object class.
'''
def __init__(self, title: str, loglevel: str=__DEFAULT_LOG_LEVEL__):
# log
LOG.set_level(loglevel)
# start logging
LOG.info('--------' * 4 + f' START LOGGING [{LOG.level}]' + '--------' * 4)
LOG.info('CLASS: World: initialize')
LOG.debug(f'-- title: {title}')
# data
self._config = StoryConfig(title)
self._db = Database()
# command
self._cmd = StoryCmd(self._db)
self._tag = TagCmd()
# hook method
self.chapter = self._cmd.chapter
self.episode = self._cmd.episode
self.scene = self._cmd.scene
self.plot_note = self._cmd.plot_note
self.foreshadow = self._cmd.foreshadow
self.payoff = self._cmd.payoff
self.motif = self._cmd.motif
self.plot_setup = self._cmd.plot_setup
self.plot_develop = self._cmd.plot_develop
self.plot_resolve = self._cmd.plot_resolve
self.plot_turnpoint = self._cmd.plot_turnpoint
self.writer_note = self._cmd.writer_note
self.chara_note = self._cmd.character_note
self.document = self._cmd.document
self.br = self._tag.br
self.comment = self._tag.comment
self.symbol = self._tag.symbol
self._config.set_log_level(loglevel)
self.change_camera = self.cmd.change_camera
self.change_stage = self.cmd.change_stage
self.change_date = self.cmd.change_date
self.change_time = self.cmd.change_time
#
# static methods
#
@staticmethod
def create_world(title: str) -> World: # pragma: no cover
''' Get world class instance.
'''
# first print
print(f'>> Build by {__TITLE__}(v{__VERSION__})')
# log level set
LOG.reset_logger(OptionParser().get_commandline_arguments())
tmp = World(title)
# default settings
tmp.config.set_modified(get_date_lastmodified(get_module_filename(2)))
return tmp
#
# property
#
@property
def config(self) -> StoryConfig:
return self._config
@property
def db(self) -> Database:
return self._db
@property
def cmd(self) -> StoryCmd:
return self._cmd
@property
def tag(self) -> TagCmd:
return self._tag
#
# methods
#
def get(self, key: str) -> Writer:
return Writer(self._db.get(key))
def run(self, *args: (Chapter, Episode, Scene, SCode)) -> int: # pragma: no cover
''' Run the story builder.
'''
LOG.info('WORLD: START: run')
exit_msg = ''
exit_code = 0
try:
LOG.info('WORLD: create story object')
# TODO: validate args
tmp = Story(self.config.title, *args, outline=self.config.outline)
LOG.info('WORLD: START: runner')
result = assertion.is_instance(
Runner().execute(tmp, self.config, self.db),
ResultData)
if not result.is_succeeded:
if result.error:
raise result.error
else:
raise BuilderError('Other Builder Error!!')
LOG.info('... SUCCESS: runner')
except Exception as e:
import traceback
ex_traceback = traceback.format_exc()
exit_msg += '==== BUILDER ERROR ====\n' + '\n'.join(VERSION_MSG)
exit_msg += f'\n: {ex_traceback}'
exit_code = 1
except SystemExit as ex:
if ex.code is not None:
if not isinstance(ex.code, int):
exit_msg = ex_code
exit_code = 1
else:
exit_code = ex.code
finally:
import sys
if exit_msg:
LOG.critical(exit_msg)
if exit_msg:
sys.stderr.write(exit_msg)
return exit_code
def test_instance(self):
tmp = cmd.StoryCmd(Database())
self.assertIsInstance(tmp, cmd.StoryCmd)