def build_index(journal_list): """Create an index.html file for HTML output from journal list. Args: journal_list: [array of path] Path to the journal files to put in the index. Assumes that there is a corresponding .html file for each to link to. """ document_manager = HtmlDocumentManager(title='Journal Summary') document_manager.has_key = False document_manager.has_global_expand = False processor = HtmlIndexRenderer(document_manager) for journal in journal_list: processor.process(journal) processor.terminate() tr = document_manager.make_tag_container( 'tr', [document_manager.make_tag_text('th', name) for name in processor.output_column_names]) table = document_manager.make_tag_container( 'table', [tr], style='font-size:12pt') document_manager.wrap_tag(table) document_manager.build_to_path('index.html')
def build_table(journal_list, output_dir): document_manager = HtmlDocumentManager(title='Journal Summary') document_manager.has_key = False document_manager.has_global_expand = False HtmlIndexTableRenderer.process_all(document_manager, journal_list, output_dir) document_manager.build_to_path(os.path.join(output_dir, 'table_index.html'))
def test_expandable_control(self): """Test the production of HTML controller for show/hide.""" manager = HtmlDocumentManager('test_json') # Test block both as being initially expanded then not. tag = manager.make_expandable_control_tag('SID', 'TEST') self.assertEqual( '<a class="toggle" onclick="toggle_inline(\'SID\');">TEST</a>', str(tag))
def test_expandable_tag_attrs(self): """Test the production of HTML tag decorators controling show/hide.""" manager = HtmlDocumentManager('test_json') section_id = 'SID' # Test block both as being initially expanded then not. detail_tags, summary_tags = manager.make_expandable_tag_attr_kwargs_pair( section_id, default_expanded=True) self.assertEqual({'id': 'SID.1'}, detail_tags) self.assertEqual({'id': 'SID.0', 'style': 'display:none'}, summary_tags) detail_tags, summary_tags = manager.make_expandable_tag_attr_kwargs_pair( section_id, default_expanded=False) self.assertEqual({'id': 'SID.1', 'style': 'display:none'}, detail_tags) self.assertEqual({'id': 'SID.0'}, summary_tags)
def test_expandable_tag_attrs(self): """Test the production of HTML tag decorators controling show/hide.""" manager = HtmlDocumentManager('test_json') section_id = 'SID' # Test block both as being initially expanded then not. detail_tags, summary_tags = manager.make_expandable_tag_attr_pair( section_id, default_expanded=True) self.assertEqual(' id="SID.1"', detail_tags) self.assertEqual(' id="SID.0" style="display:none"', summary_tags) detail_tags, summary_tags = manager.make_expandable_tag_attr_pair( section_id, default_expanded=False) self.assertEqual(' id="SID.1" style="display:none"', detail_tags) self.assertEqual(' id="SID.0"', summary_tags)
def test_process_snapshot(self): """Test the conversion of a snapshot into HTML.""" tail = TestLinkedList(name='tail') head = TestLinkedList(name='head', next_elem=tail) snapshot = JsonSnapshot() snapshot.make_entity_for_object(head) json_snapshot = snapshot.to_json_object() entity_manager = ProcessedEntityManager() processor = ProcessToRenderInfo(HtmlDocumentManager('test_json'), entity_manager) processor.max_uncollapsable_json_lines = 20 processor.max_uncollapsable_metadata_rows = 20 processor.max_uncollapsable_entity_rows = 20 processor.default_force_top_level_collapse = False in_relation = None entity_manager.push_entity_map(json_snapshot['_entities']) html_info = processor.process_entity_id(json_snapshot['_subject_id'], json_snapshot, in_relation) entity_manager.pop_entity_map(json_snapshot['_entities']) expect = """<table> <tr> <th><i>metadata</i></th> <td> <table> <tr><th>_id</th><td>1</td></tr> <tr><th>class</th><td>type TestLinkedList</td></tr> <tr><th>name</th><td>head</td></tr> </table> </td> </tr> <tr> <th>Next</th> <td> <table> <tr> <th><i>metadata</i></th> <td> <table> <tr><th>_id</th><td>2</td></tr> <tr><th>class</th><td>type TestLinkedList</td></tr> <tr><th>name</th><td>tail</td></tr> </table> </td> </tr> </table> </td> </tr> </table> """ # Test without regard to whitespace formatting. self.assertEquals(''.join(expect.split()), ''.join(str(html_info.detail_block).split()))
def test_json(self): """Test rendering literal json values""" processor = ProcessToRenderInfo(HtmlDocumentManager('test_json'), ProcessedEntityManager()) processor.max_uncollapsable_json_lines = 20 processor.max_uncollapsable_entity_rows = 20 # Numeric literals wont be treated as json. for n in [-1, 0, 1, 3.14]: info = processor.process_json_html_if_possible(n) self.assertEquals('{0}'.format(n), info.detail_html) self.assertEquals(None, info.summary_html) # None of these strings are well-defined JSON documents # so should just be strings. for s in ['test', 'a phrase', 'True']: info = processor.process_json_html_if_possible(s) self.assertEquals('"{0}"'.format(s), info.detail_html) self.assertEquals(None, info.summary_html) # Boolean values wont be considered JSON. for b in [True, False]: info = processor.process_json_html_if_possible(b) self.assertEquals('{0}'.format(str(b)), info.detail_html) self.assertEquals(None, info.summary_html) # Dictionaries and JSON dictionary strings normalize to JSON. for d in [{'A': 'a', 'B': True}, '{"A":"a", "B":true}']: info = processor.process_json_html_if_possible(d) self.assertEquals( '<pre>{{\n "A": "a",\n' ' "B": true\n' '}}</pre>'.format(), info.detail_html) self.assertEquals(None, info.summary_html) self.assertEquals(None, info.summary_html) # Lists and JSON lists strings normalize to JSON. for l in [[123, 'abc', True, { 'A': 'a', 'B': 'b' }], '[123, "abc", true, {"A":"a", "B":"b"}]']: info = processor.process_json_html_if_possible(l) self.assertEquals( '<pre>[\n 123,\n "abc",\n true,\n' ' {{\n' ' "A": "a",\n' ' "B": "b"\n' ' }}\n' ']</pre>'.format(), info.detail_html) self.assertEquals(None, info.summary_html)
def test_cycle(self): tail = TestLinkedList(name='tail') head = TestLinkedList(name='head', next_elem=tail) tail.next = head snapshot = JsonSnapshot() entity_manager = ProcessedEntityManager() processor = ProcessToRenderInfo(HtmlDocumentManager('test_json'), entity_manager) snapshot.make_entity_for_object(head) json_snapshot = snapshot.to_json_object() self.assertEqual(1, json_snapshot.get('_subject_id')) entity_manager.push_entity_map(json_snapshot.get('_entities')) info = processor.process_entity_id(1, snapshot)
def test_yaml(self): """Test rendering literal json values""" processor = ProcessToRenderInfo(HtmlDocumentManager('test_yaml'), ProcessedEntityManager()) processor.max_uncollapsable_json_lines = 20 processor.max_uncollapsable_entity_rows = 20 # Numeric literals wont be treated as yaml for n in [-1, 0, 1, 3.14]: info = processor.process_yaml_html_if_possible(n) self.assertEquals('{0}'.format(n), info.detail_block) self.assertEquals(None, info.summary_block) # None of these strings are well-defined YAML documents # so should just be strings. for s in ['test', 'a phrase']: info = processor.process_yaml_html_if_possible(s) self.assertEquals('<pre>%s\n</pre>' % s, info.detail_block) self.assertEquals(None, info.summary_block) info = processor.process_yaml_html_if_possible('True') self.assertEquals('<pre>true\n</pre>', info.detail_block) # Boolean values wont be considered YAML for b in [True, False]: info = processor.process_yaml_html_if_possible(b) self.assertEquals('{0}'.format(str(b)), info.detail_block) self.assertEquals(None, info.summary_block) # Dictionaries and YAML dictionary strings normalize to YAML import yaml for d in [{'A': 'a', 'B': True}, 'A: a\nB: true\n']: info = processor.process_yaml_html_if_possible(d) # The eolns here show that it is being yaml formatted. self.assertEquals('<pre>A:a\nB:true\n</pre>', str(info.detail_block).replace(' ', '')) self.assertEquals(None, info.summary_block) self.assertEquals(None, info.summary_block) # Lists and YAML lists strings normalize to YAML. for l in [[123, 'abc', True, { 'A': 'a', 'B': 'b' }], '[123, "abc", true, {"A":"a", "B":"b"}]']: info = processor.process_yaml_html_if_possible(l) self.assertEquals( '<pre>-123\n-abc\n-true\n-A:a\nB:b\n</pre>', str(info.detail_block).replace(' ', '').replace('\n', '\n')) self.assertEquals(None, info.summary_block)
def journal_to_html(input_path, prune=False): """Main program for converting a journal JSON file into HTML. This will write a file using in the input_path directory with the same basename as the JSON file, but with 'html' extension instead. Args: input_path: [string] Path the journal file. """ output_path = os.path.basename(os.path.splitext(input_path)[0]) + '.html' document_manager = HtmlDocumentManager( title='Report for {0}'.format(os.path.basename(input_path))) processor = HtmlRenderer(document_manager, prune=prune) processor.process(StreamJournalNavigator.new_from_path(input_path)) processor.terminate() document_manager.wrap_tag(document_manager.new_tag('table')) document_manager.build_to_path(output_path)
def journal_to_html(input_path): """Main program for converting a journal JSON file into HTML. This will write a file using in the input_path directory with the same basename as the JSON file, but with 'html' extension instead. Args: input_path: [string] Path the journal file. """ output_path = os.path.basename(os.path.splitext(input_path)[0]) + '.html' document_manager = HtmlDocumentManager( title='Report for {0}'.format(os.path.basename(input_path))) processor = HtmlRenderer(document_manager) processor.process(input_path) processor.terminate() document_manager.wrap_tag(document_manager.new_tag('table')) document_manager.build_to_path(output_path)
def build_index(journal_list, output_dir): """Create an index.html file for HTML output from journal list. Args: journal_list: [array of path] Path to the journal files to put in the index. Assumes that there is a corresponding .html file for each to link to. """ document_manager = HtmlDocumentManager(title='Journal Summary') document_manager.has_key = False document_manager.has_global_expand = False processor = HtmlIndexRenderer(document_manager) for journal in journal_list: processor.process(StreamJournalNavigator.new_from_path(journal)) processor.terminate() tr_tag = document_manager.make_tag_container('tr', [ document_manager.make_tag_text('th', name) for name in processor.output_column_names ]) table = document_manager.make_tag_container('table', [tr_tag], style='font-size:12pt') document_manager.wrap_tag(table) document_manager.build_to_path(os.path.join(output_dir, 'index.html'))