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)