jswriter.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
from robot.htmldata import JsonWriter
 
 
class JsResultWriter:
    
    _output_attr = 'window.output'
    
    _settings_attr = 'window.settings'
    
    _suite_key = 'suite'
    
    _strings_key = 'strings'
 
    def __init__(self, output,
                 start_block='<script type="text/javascript">\n',
                 end_block='</script>\n',
                 split_threshold=9500):
        writer = JsonWriter(output, separator=end_block+start_block)
        self._write_write = writer.write
        self._write_json_write_json = writer.write_json
        self._start_block_start_block = start_block
        self._end_block_end_block = end_block
        self._split_threshold_split_threshold = split_threshold
 
    def write(self, result, settings):
        self._start_output_block_start_output_block()
        self._write_suite_write_suite(result.suite)
        self._write_strings_write_strings(result.strings)
        self._write_data_write_data(result.data)
        self._write_settings_and_end_output_block_write_settings_and_end_output_block(settings)
 
    def _start_output_block(self):
        self._write_write(self._start_block_start_block, postfix='', separator=False)
        self._write_write('%s = {}' % self._output_attr_output_attr)
 
    def _write_suite(self, suite):
        writer = SuiteWriter(self._write_json_write_json, self._split_threshold_split_threshold)
        writer.write(suite, self._output_var_output_var(self._suite_key_suite_key))
 
    def _write_strings(self, strings):
        variable = self._output_var_output_var(self._strings_key_strings_key)
        self._write_write('%s = []' % variable)
        prefix = '%s = %s.concat(' % (variable, variable)
        postfix = ');\n'
        threshold = self._split_threshold_split_threshold
        for index in range(0, len(strings), threshold):
            self._write_json_write_json(prefix, strings[index:index+threshold], postfix)
 
    def _write_data(self, data):
        for key in data:
            self._write_json_write_json('%s = ' % self._output_var_output_var(key), data[key])
 
    def _write_settings_and_end_output_block(self, settings):
        self._write_json_write_json('%s = ' % self._settings_attr_settings_attr, settings,
                         separator=False)
        self._write_write(self._end_block_end_block, postfix='', separator=False)
 
    def _output_var(self, key):
        return '%s["%s"]' % (self._output_attr_output_attr, key)
 
 
class SuiteWriter:
 
    def __init__(self, write_json, split_threshold):
        self._write_json_write_json = write_json
        self._split_threshold_split_threshold = split_threshold
 
    def write(self, suite, variable):
        mapping = {}
        self._write_parts_over_threshold_write_parts_over_threshold(suite, mapping)
        self._write_json_write_json('%s = ' % variable, suite, mapping=mapping)
 
    def _write_parts_over_threshold(self, data, mapping):
        if not isinstance(data, tuple):
            return 1
        not_written = 1 + sum(self._write_parts_over_threshold_write_parts_over_threshold(item, mapping)
                              for item in data)
        if not_written > self._split_threshold_split_threshold:
            self._write_part_write_part(data, mapping)
            return 1
        return not_written
 
    def _write_part(self, data, mapping):
        part_name = 'window.sPart%d' % len(mapping)
        self._write_json_write_json('%s = ' % part_name, data, mapping=mapping)
        mapping[data] = part_name
 
 
class SplitLogWriter:
 
    def __init__(self, output):
        self._writer_writer = JsonWriter(output)
 
    def write(self, keywords, strings, index, notify):
        self._writer_writer.write_json('window.keywords%d = ' % index, keywords)
        self._writer_writer.write_json('window.strings%d = ' % index, strings)
        self._writer_writer.write('window.fileLoading.notify("%s")' % notify)