Ejemplo n.º 1
0
def getLicensePortletText(context, uri):
    """\
    Generates a brief terms of use/license description that is based on
    the input uri for use by the portlet.
    """

    if not uri:
        return u'The terms of use/license for this work is unspecified.'

    # get the URI from the object
    results = getLicenses(context, pmr2_license_uri=uri)
    license = None
    if results:
        # Assume the first one.
        license = results[0].getObject()
        if license.portlet_text:
            pt = getToolByName(input, 'portal_transforms')
            stream = datastream('license_description')
            pt.convert('safe_html', license.portlet_text, stream)
            return stream.getData()

    # template undefined, we generate one.
    # XXX ideally this should be a proper template/view.
    license_template = \
        u'The terms of use for this work and/or license this work is under ' \
         'is: <a href=%s>%s</a>.'

    title = license and license.title or escape(uri)
    return license_template % (quoteattr(uri), title)
Ejemplo n.º 2
0
    def convert(self, data, cache, **kwargs):
      kwargs['filename'] = 'input.tiff'
      tmp_dir, input_file = self.initialize_tmpdir(data,
                                   filename='input.tiff')

      text = None
      try:
        output_file_path = os.path.join(tmp_dir, 'output')
        cmd = self.binary, input_file, output_file_path
        process = subprocess.Popen(cmd,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.STDOUT,)
        stdout = process.communicate()[0]
        err = process.returncode
        if err:
          if err < 0:
            exit_msg = 'killed with signal %s' % -err
          else:
            exit_msg = 'exited with status %s' % err
          raise EnvironmentError('Command %r %s. Command output:\n%s'
                                 % (cmd, exit_msg, stdout))

        output_file = open(output_file_path + '.txt', 'r')
        out = output_file.read()
        output_file.close()
      finally:
        self.cleanDir(tmp_dir)

      data = datastream('output.txt')
      data.setData(out)
      return data
    def test_nasty_tags(self):
        self.browser.open(
            "%s/@@filter-controlpanel" % self.portal_url)
        self.assertEqual(
            self.browser.getControl(name='form.widgets.nasty_tags').value,
            'style\nobject\nembed\napplet\nscript\nmeta')
        self.browser.getControl(
            name='form.widgets.nasty_tags').value = 'div\na'
        valid_tags = self.browser.getControl(
            name='form.widgets.valid_tags').value
        self.assertTrue(valid_tags.startswith('a\nabbr\nacronym\naddress'))
        valid_tags = valid_tags.replace('a\n', '')
        valid_tags = self.browser.getControl(
            name='form.widgets.valid_tags').value = valid_tags
        self.browser.getControl('Save').click()
        self.assertEqual(self.settings.nasty_tags, [u'div', u'a'])
        self.assertNotIn(u'a', self.settings.valid_tags)

        # test that <a> is filtered
        self.assertFalse(self.settings.disable_filtering)
        good_html = '<p><a href="http://example.com">harmless link</a></p>'
        ds = datastream('dummy_name')
        self.assertEqual(
            self.safe_html.convert(good_html, ds).getData(),
            '<p/>'
        )
 def do_convert(self, filename=None):
     if filename is None and exists(self.output + '.nofilename'):
         output = self.output + '.nofilename'
     else:
         output = self.output
     input = open(self.input)
     orig = input.read()
     input.close()
     data = datastream(self.transform.name())
     res_data = self.transform.convert(orig, data, filename=filename)
     self.assert_(idatastream.isImplementedBy(res_data))
     got = res_data.getData()
     try:
         output = open(output)
     except IOError:
         import sys
         print >>sys.stderr, 'No output file found.'
         print >>sys.stderr, 'File %s created, check it !' % self.output
         output = open(output, 'w')
         output.write(got)
         output.close()
         self.assert_(0)
     expected = output.read()
     print self.normalize
     if self.normalize is not None:
         expected = self.normalize(expected)
         got = self.normalize(got)
     output.close()
     
     self.assertEquals(got, expected,
                       '[%s]\n\n!=\n\n[%s]\n\nIN %s(%s)' % (
         got, expected, self.transform.name(), self.input))
     self.assertEquals(self.subobjects, len(res_data.getSubObjects()),
                       '%s\n\n!=\n\n%s\n\nIN %s(%s)' % (
         self.subobjects, len(res_data.getSubObjects()), self.transform.name(), self.input))
    def test_stripped_combinations(self):
        # test a combination that isn't normally filtered
        self.assertFalse(self.safe_html._config['disable_transform'])
        html = '<p class="wow">lala</p>'
        ds = datastream('dummy_name')
        self.assertEqual(
            str(self.safe_html.convert(html, ds)),
            html)

        # we can set stripped combinations
        self.browser.open(
            "%s/@@filter-controlpanel" % self.portal_url)
        self.browser.getControl(
            name='form.widgets.stripped_combinations.buttons.add').click()
        self.browser.getControl(
            name='form.widgets.stripped_combinations.key.0'
        ).value = 'mytag1 p'
        self.browser.getControl(
            name='form.widgets.stripped_combinations.0'
        ).value = 'myattr1 class'
        self.browser.getControl('Save').click()

        # stripped combinations are stored on the transform
        self.assertIn(
            'mytag1 p',
            self.safe_html._config['stripped_combinations'])
        self.assertEqual(
            'myattr1 class',
            self.safe_html._config['stripped_combinations']['mytag1 p'])

        # test that combination is now filtered
        self.assertEqual(
            str(self.safe_html.convert(html, ds)),
            '<p>lala</p>')
    def test_stripped_combinations(self):
        # test a combination that isn't normally filtered
        self.assertFalse(self.safe_html._config['disable_transform'])
        html = '<p class="wow">lala</p>'
        ds = datastream('dummy_name')
        self.assertEqual(str(self.safe_html.convert(html, ds)), html)

        # we can set stripped combinations
        self.browser.open("%s/@@filter-controlpanel" % self.portal_url)
        self.browser.getControl(
            name='form.widgets.stripped_combinations.buttons.add').click()
        self.browser.getControl(
            name='form.widgets.stripped_combinations.key.0').value = 'mytag1 p'
        self.browser.getControl(name='form.widgets.stripped_combinations.0'
                                ).value = 'myattr1 class'
        self.browser.getControl('Save').click()

        # stripped combinations are stored on the transform
        self.assertIn('mytag1 p',
                      self.safe_html._config['stripped_combinations'])
        self.assertEqual(
            'myattr1 class',
            self.safe_html._config['stripped_combinations']['mytag1 p'])

        # test that combination is now filtered
        self.assertEqual(str(self.safe_html.convert(html, ds)), '<p>lala</p>')
Ejemplo n.º 7
0
    def convert(self, data, cache, **kwargs):
        kwargs['filename'] = 'input.tiff'
        tmp_dir, input_file = self.initialize_tmpdir(data,
                                                     filename='input.tiff')

        text = None
        try:
            output_file_path = os.path.join(tmp_dir, 'output')
            cmd = self.binary, input_file, output_file_path
            process = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
            )
            stdout = process.communicate()[0]
            err = process.returncode
            if err:
                if err < 0:
                    exit_msg = 'killed with signal %s' % -err
                else:
                    exit_msg = 'exited with status %s' % err
                raise EnvironmentError('Command %r %s. Command output:\n%s' %
                                       (cmd, exit_msg, stdout))

            output_file = open(output_file_path + '.txt', 'r')
            out = output_file.read()
            output_file.close()
        finally:
            self.cleanDir(tmp_dir)

        data = datastream('output.txt')
        data.setData(out.rstrip())  # .rstrip() also removes page breaks
        return data
Ejemplo n.º 8
0
 def setUp(self):
     self.workdir = tempfile.mkdtemp()
     input_dir = os.path.join(os.path.dirname(__file__), 'input')
     self.doc_simple1_path = os.path.join(input_dir, 'simpledoc1.doc')
     self.doc_simple1 = open(self.doc_simple1_path, 'rb').read()
     self.idata = datastream('mytestdoc.doc')
     self.idata.setData(self.doc_simple1)
     self.doc = None   # to be set by tests
Ejemplo n.º 9
0
 def test_cnxmlplus2cnxml(self):
     cnxmlplus = open(os.path.join(dirname, 'test.cnxmlplus')).read()
     transform = cnxmlplus_to_shortcodecnxml()
     data = datastream('cnxml')
     data = transform.convert(cnxmlplus, data) 
     data = data.getData()
     self.assertTrue(len(data) > 0)
     self.assertNotEquals(cnxmlplus, data)
Ejemplo n.º 10
0
 def test_get_cache_key_no_key(self):
     # contexts w/o given key result in ``None``
     base = OOOTransformBase()
     context = FakeContext()
     stream = datastream('mystream')
     stream.context = context
     result = base.get_cache_key('invalid-key', stream)
     assert result is None
Ejemplo n.º 11
0
 def test_get_cache_key(self):
     # OOOTransformBase instances can get cache keys
     base = OOOTransformBase()
     context = FakeContext()
     stream = datastream('mystream')
     stream.context = context
     result = base.get_cache_key('some_key', stream)
     assert result == 'foo'
Ejemplo n.º 12
0
 def contents(self):
     data = self.request['_data']
     rev = self.request['rev']
     contents = fix_workspace_html_anchors(data['contents'](),
         self.context.absolute_url(), rev)
     pt = getToolByName(self.context, 'portal_transforms')
     stream = datastream('input')
     pt.convert('safe_html', contents, stream)
     return stream.getData()
Ejemplo n.º 13
0
 def test_convert(self):
     # we can convert odt docs to PDF.
     transform = Odt2Pdf()
     idatastream = datastream('mystream')
     transform.convert(
         open(self.src_path2, 'r').read(),
         idatastream)
     self.assertEqual(idatastream.getData()[:7], '%PDF-1.')
     self.assertEqual(idatastream.getMetadata(), {'cache_key_pdf': None})
Ejemplo n.º 14
0
 def _test_cnxmlplus2html_chain(self):
     """ This looks more like a functional than unittest since it exercises
         all the others too. Maybe we should move it.
     """
     cnxmlplus = open(os.path.join(dirname, 'test.cnxmlplus')).read()
     pt = getToolByName(self.portal, 'portal_transforms')
     transform = pt['cnxmlplus_to_html_chain']
     data = datastream(cnxmlplus)
     data = transform.convert(cnxmlplus, data) 
Ejemplo n.º 15
0
 def test_convert(self):
     # we can convert odt docs to HTML.
     transform = Odt2Html()
     idatastream = datastream('mystream')
     transform.convert(
         open(self.src_path2, 'r').read(),
         idatastream)
     assert '</span>' in idatastream.getData()
     self.assertEqual(idatastream.getMetadata(), {'cache_key_html': None})
Ejemplo n.º 16
0
    def test_nasty_tags(self):
        self.browser.open("%s/@@filter-controlpanel" % self.portal_url)
        self.browser.getControl(name="form.widgets.nasty_tags").value = "div\r\na"
        self.browser.getControl("Save").click()

        # test that <a> is filtered
        self.assertFalse(self.safe_html._config["disable_transform"])
        good_html = '<a href="http://example.com">harmless link</a>'
        ds = datastream("dummy_name")
        self.assertEqual(str(self.safe_html.convert(good_html, ds)), "")
    def test_nasty_tags(self):
        self.browser.open("%s/@@filter-controlpanel" % self.portal_url)
        self.browser.getControl(
            name='form.widgets.nasty_tags').value = 'div\r\na'
        self.browser.getControl('Save').click()

        # test that <a> is filtered
        self.assertFalse(self.safe_html._config['disable_transform'])
        good_html = '<p><a href="http://example.com">harmless link</a></p>'
        ds = datastream('dummy_name')
        self.assertEqual(str(self.safe_html.convert(good_html, ds)), '')
Ejemplo n.º 18
0
    def test_transform_doesnt_swallow_conflict_errors(self):
        stream = datastream('dummy')

        # Patch TikaConverter class to just raise a ConflictError
        MockConverter = self.mocker.replace('ftw.tika.converter.TikaConverter')
        self.expect(MockConverter()).result(RaisingConverter(ConflictError))
        self.replay()

        transform = Tika2TextTransform()
        with self.assertRaises(ConflictError):
            transform.convert('', stream)
Ejemplo n.º 19
0
 def convertTo(self,
               target_mimetype,
               orig,
               data=None,
               object=None,
               **kwargs):
     assert orig == self.expected, '????'
     if data is None:
         data = datastream('test')
     data.setData(orig)
     return data
Ejemplo n.º 20
0
    def test_disable_filtering(self):
        self.browser.open("%s/@@filter-controlpanel" % self.portal_url)
        self.browser.getControl(name="form.widgets.disable_filtering:list").value = "selected"
        self.browser.getControl("Save").click()

        # test that the transform is disabled
        self.assertEqual(self.safe_html._config["disable_transform"], 1)

        # anything passes
        nasty_html = "<script></script>"
        ds = datastream("dummy_name")
        self.assertEqual(nasty_html, str(self.safe_html.convert(nasty_html, ds)))
Ejemplo n.º 21
0
    def do_convert(self, filename=None):
        if filename is None and exists(self.output + '.nofilename'):
            output = self.output + '.nofilename'
        else:
            output = self.output
        orig = read_file_data(self.input)
        data = datastream(self.transform.name())
        res_data = self.transform.convert(orig, data, filename=filename)
        self.assertTrue(IDataStream.providedBy(res_data))
        got = res_data.getData()

        self.assertIsInstance(got, self.allowed_types)
        try:
            expected = read_file_data(self.output)
        except IOError:
            expected = ''
            import sys
            print('No output file found.', file=sys.stderr)
            print('File {0} created, check it !'.format(self.output),
                  file=sys.stderr)
            with open(output, 'w') as fd:
                fd.write(got)
            self.assertTrue(0)

        if self.normalize is not None:
            got = self.normalize(got)
            expected = self.normalize(expected)

        # show the first character ord table for debugging
        got_start = got.strip()[:20]
        expected_start = expected.strip()[:20]
        msg = 'IN {0}({1}) expected:\n{2}\nbut got:\n{3}'.format(
            self.transform.name(),
            self.input,
            "%s %s" % (expected_start, str([ord(x) for x in expected_start])),
            "%s %s" % (got_start, str([ord(x) for x in got_start])),
        )

        # compare md5 sum of the whole file content
        self.assertEqual(
            got_start,
            expected_start,
            msg,
        )
        self.assertEqual(
            self.subobjects, len(res_data.getSubObjects()),
            '%s\n\n!=\n\n%s\n\nIN %s(%s)' % (
                self.subobjects,
                len(res_data.getSubObjects()),
                self.transform.name(),
                self.input,
            ))
    def test_disable_filtering(self):
        self.browser.open("%s/@@filter-controlpanel" % self.portal_url)
        self.browser.getControl(
            name='form.widgets.disable_filtering:list').value = "selected"
        self.browser.getControl('Save').click()

        # test that the transform is disabled
        self.assertEqual(self.safe_html._config['disable_transform'], 1)

        # anything passes
        nasty_html = '<script></script>'
        ds = datastream('dummy_name')
        self.assertEqual(nasty_html,
                         str(self.safe_html.convert(nasty_html, ds)))
Ejemplo n.º 23
0
    def do_convert(self, filename=None):
        if filename is None and exists(self.output + '.nofilename'):
            output = self.output + '.nofilename'
        else:
            output = self.output
        with open(self.input) as fp:
            orig = fp.read()
        data = datastream(self.transform.name())
        res_data = self.transform.convert(orig, data, filename=filename)
        self.assert_(IDataStream.providedBy(res_data))
        got = res_data.getData()
        try:
            output = open(output)
        except IOError:
            import sys
            print >> sys.stderr, 'No output file found.'
            print >> sys.stderr, 'File %s created, check it !' % self.output
            output = open(output, 'w')
            output.write(got)
            output.close()
            self.assert_(0)
        expected = output.read()
        if self.normalize is not None:
            expected = self.normalize(expected)
            got = self.normalize(got)
        output.close()

        got_start = got.strip()[:20]
        expected_start = expected.strip()[:20]
        msg = 'IN {0}({1}) expected:\n{2}\nbut got:\n{3}'.format(
            self.transform.name(),
            self.input,
            str([ord(x) for x in expected_start]),
            str([ord(x) for x in got_start]),
        )
        self.assertEqual(
            got_start,
            expected_start,
            msg
        )
        self.assertEqual(
            self.subobjects,
            len(res_data.getSubObjects()),
            '%s\n\n!=\n\n%s\n\nIN %s(%s)' % (
                self.subobjects,
                len(res_data.getSubObjects()),
                self.transform.name(),
                self.input
            )
        )
Ejemplo n.º 24
0
 def test_convert_with_cachekey(self):
     # we retrieve cached files if cache_key is set and valid
     cache_key = self.register_fakedoc_in_cache(
         src=self.src_path1, options=OPTIONS_HTML)
     transform = Odt2Html(cache_dir=self.cachedir)
     idatastream = datastream('mystream')
     # set cache key for HTML
     idatastream.context = FakeContext(html_key=cache_key)
     transform.convert(
         # We give a different source than what was cached as source.
         # This way we can be sure that if we get the fake result, it was
         # really retrieved via cache key lookup and not via source
         # lookup.
         open(self.src_path2, 'r').read(),
         idatastream)
     assert idatastream.getData() == 'A fake result.'
Ejemplo n.º 25
0
def convert(markup):
    """Use this function to transform markup from trix to markup that can
    be processed by sablon.

    This converter is expected to do nothing since trix markup is already valid
    for sablon. It is just a safeguard against malicious markup injection or
    against changes in trix.

    Thus we also log to sentry whenever we actually have to convert markup.

    """
    data = _transform.convert(markup, data=datastream('trix_to_sablon'))
    converted = data.getData()
    if converted != markup:
        _log_unexpected_conversion_to_sentry(converted, markup)
    return converted
Ejemplo n.º 26
0
def convert(markup):
    """Use this function to transform markup from trix to markup that can
    be processed by sablon.

    This converter is expected to do nothing since trix markup is already valid
    for sablon. It is just a safeguard against malicious markup injection or
    against changes in trix.

    Thus we also log to sentry whenever we actually have to convert markup.

    """
    data = _transform.convert(markup, data=datastream('trix_to_sablon'))
    converted = data.getData()
    if converted != markup:
        _log_unexpected_conversion_to_sentry(converted, markup)
    return converted
    def test_nasty_tags(self):
        self.browser.open("%s/@@filter-controlpanel" % self.portal_url)
        self.browser.getControl(
            name='form.widgets.nasty_tags').value = 'div\r\na'
        valid_tags = self.browser.getControl(
            name='form.widgets.valid_tags').value
        valid_tags = valid_tags.replace('a\r\n', '')
        valid_tags = self.browser.getControl(
            name='form.widgets.valid_tags').value = valid_tags
        self.browser.getControl('Save').click()

        # test that <a> is filtered
        self.assertFalse(self.settings.disable_filtering)
        good_html = '<p><a href="http://example.com">harmless link</a></p>'
        ds = datastream('dummy_name')
        self.assertEqual(str(self.safe_html.convert(good_html, ds)), '<p/>')
Ejemplo n.º 28
0
    def generate(self):
        reader = libsbml.SBMLReader()
        doc = reader.readSBMLFromString(self.input)
        model = doc.getModel()

        pt = getToolByName(self.context, 'portal_transforms', None)
        if pt:
            stream = datastream('license_description')
            pt.convert('safe_html', model.getNotesString(), stream)
            text = stream.getData().decode('utf8', 'ignore')
        else:
            # XXX should warn unsafe
            text = model.getNotesString()

        return (
            ('text', text,),
        )
    def test_disable_filtering(self):
        self.browser.open(
            "%s/@@filter-controlpanel" % self.portal_url)
        self.browser.getControl(
            name='form.widgets.disable_filtering:list').value = "selected"
        self.browser.getControl('Save').click()

        # test that the transform is disabled
        self.assertEqual(
            self.settings.disable_filtering,
            1)

        # anything passes
        nasty_html = '<script></script>'
        ds = datastream('dummy_name')
        self.assertEqual(
            nasty_html,
            str(self.safe_html.convert(nasty_html, ds))
        )
    def do_convert(self, filename=None):
        if filename is None and exists(self.output + ".nofilename"):
            output = self.output + ".nofilename"
        else:
            output = self.output
        input = open(self.input)
        orig = input.read()
        input.close()
        data = datastream(self.transform.name())
        res_data = self.transform.convert(orig, data, filename=filename)
        self.assert_(IDataStream.providedBy(res_data))
        got = res_data.getData()
        try:
            output = open(output)
        except IOError:
            import sys

            print >> sys.stderr, "No output file found."
            print >> sys.stderr, "File %s created, check it !" % self.output
            output = open(output, "w")
            output.write(got)
            output.close()
            self.assert_(0)
        expected = output.read()
        if self.normalize is not None:
            expected = self.normalize(expected)
            got = self.normalize(got)
        output.close()

        got_start = got.strip()[:20]
        expected_start = expected.strip()[:20]
        self.assertEquals(
            got_start,
            expected_start,
            "[%s]\n\n!=\n\n[%s]\n\nIN %s(%s)" % (got_start, expected_start, self.transform.name(), self.input),
        )
        self.assertEquals(
            self.subobjects,
            len(res_data.getSubObjects()),
            "%s\n\n!=\n\n%s\n\nIN %s(%s)"
            % (self.subobjects, len(res_data.getSubObjects()), self.transform.name(), self.input),
        )
Ejemplo n.º 31
0
    def test_stripped_combinations(self):
        # test a combination that isn't normally filtered
        self.assertFalse(self.safe_html._config["disable_transform"])
        html = '<p class="wow">lala</p>'
        ds = datastream("dummy_name")
        self.assertEqual(str(self.safe_html.convert(html, ds)), html)

        # we can set stripped combinations
        self.browser.open("%s/@@filter-controlpanel" % self.portal_url)
        self.browser.getControl(name="form.widgets.stripped_combinations.buttons.add").click()
        self.browser.getControl(name="form.widgets.stripped_combinations.key.0").value = "mytag1 p"
        self.browser.getControl(name="form.widgets.stripped_combinations.0").value = "myattr1 class"
        self.browser.getControl("Save").click()

        # stripped combinations are stored on the transform
        self.assertIn("mytag1 p", self.safe_html._config["stripped_combinations"])
        self.assertEqual("myattr1 class", self.safe_html._config["stripped_combinations"]["mytag1 p"])

        # test that combination is now filtered
        self.assertEqual(str(self.safe_html.convert(html, ds)), "<p>lala</p>")
Ejemplo n.º 32
0
    def convert(self, data, cache, **kwargs):
      kwargs['filename'] = 'input.tiff'
      tmp_dir, input_file = self.initialize_tmpdir(data, 
                                   filename='input.tiff')

      text = None
      try:
        command = self.binary
        output_file_path = os.path.join(tmp_dir, 'output')
        cmd = '%s %s %s' % (
            self.binary, input_file, output_file_path)
        os.system(cmd)
        output_file = open(output_file_path + '.txt', 'r')
        out = output_file.read()
        output_file.close()
      finally:
        self.cleanDir(tmp_dir)

      data = datastream('output.txt')
      data.setData(out)
      return data
Ejemplo n.º 33
0
    def do_convert(self, filename=None):
        if filename is None and exists(self.output + '.nofilename'):
            output = self.output + '.nofilename'
        else:
            output = self.output
        input = open(self.input)
        orig = input.read()
        input.close()
        data = datastream(self.transform.name())
        res_data = self.transform.convert(orig, data, filename=filename)
        self.assert_(IDataStream.providedBy(res_data))
        got = res_data.getData()
        try:
            output = open(output)
        except IOError:
            import sys
            print >> sys.stderr, 'No output file found.'
            print >> sys.stderr, 'File %s created, check it !' % self.output
            output = open(output, 'w')
            output.write(got)
            output.close()
            self.assert_(0)
        expected = output.read()
        if self.normalize is not None:
            expected = self.normalize(expected)
            got = self.normalize(got)
        output.close()

        got_start = got.strip()[:30]
        expected_start = expected.strip()[:30]
        self.assertEquals(
            got_start, expected_start, '[%s]\n\n!=\n\n[%s]\n\nIN %s(%s)' %
            (got_start, expected_start, self.transform.name(), self.input))
        self.assertEquals(
            self.subobjects, len(res_data.getSubObjects()),
            '%s\n\n!=\n\n%s\n\nIN %s(%s)' %
            (self.subobjects, len(
                res_data.getSubObjects()), self.transform.name(), self.input))
Ejemplo n.º 34
0
 def test_shortcodecnxml2shortcodehtml(self):
     cnxml = open(os.path.join(dirname, 'test.cnxml')).read()
     transform = shortcodecnxml_to_shortcodehtml()
     data = datastream('cnxml')
     data = transform.convert(cnxml, data) 
Ejemplo n.º 35
0
 def convert(self, input):
     pt = getToolByName(self.context, 'portal_transforms')
     stream = datastream('pt_annotation')
     pt.convert(self.transform, input, stream)
     return stream.getData()
Ejemplo n.º 36
0
    def texSlideSection(self, section):
        type = self.slideSectionType(section)
        # Neither image or text, ignore section
        if not section.image_code and not section.text:
            return
        if type == 'explanation':
            # Explanations are only useful as footnotes to slides
            return

        if type == 'main':
            # Write out approximation to slide

            self.writeTeX(['\\fbox{']);

            # Main section text goes into a slide minipage
            if section.text and section.text.raw:
                self.writeTeX([
                    '\\begin{minipage}{' + ('0.58' if section.image_code else '0.97') + '\\textwidth}',
                    section.text,
                    '\\end{minipage}',
                ])

            # If there is an image, write it into a minipage
            if section.image_code and section.image_code.raw:
                tf = ScriptToTeX()
                data = tf.convert(
                    section.image_code.raw,
                    datastream("scriptToImage"),
                    mimetype='text/x-uri' if section.image_code.mimeType == 'text/x-url' else section.image_code.mimeType)

                self.writeTeX([
                    '\\hspace{0.5mm}',
                    '\\begin{minipage}{' + ('0.38' if type != 'main' or section.text else '0.97') + '\\textwidth}',
                    data.getData(),
                    '\scriptsize ' + section.image_caption if section.image_caption else '',
                    '\\end{minipage}',
                ])

            self.writeTeX(['}']);

        else:
            self.writeTeX(['\\subsubsection{' + section.title + '}'])

            # Write out floating image
            if section.image_code and section.image_code.raw:
                tf = ScriptToTeX()
                data = tf.convert(
                    section.image_code.raw,
                    datastream("scriptToImage"),
                    mimetype='text/x-uri' if section.image_code.mimeType == 'text/x-url' else section.image_code.mimeType)

                self.writeTeX([
                    '\\begin{figure}[h]',
                    '\\hspace{0.5mm}',
                    '\\begin{minipage}{0.48\\textwidth}',
                    data.getData(),
                    '\\caption{%s}' % section.image_caption if section.image_caption else '',
                    '\\end{minipage}',
                    '\\end{figure}',
                ])

            # Rest of text goes in verbatim
            self.writeTeX([section.text])
Ejemplo n.º 37
0
    def texSlideSection(self, obj):
        type = self.slideSectionType(obj)
        if type == 'main':
            isExpl = False
        elif type == 'explanation':
            isExpl = True
        else:
            # Ignore other sections
            return

        haveText = (obj.text and obj.text.raw)
        haveImage = (obj.image_code and obj.image_code.raw)

        if self.slideInfo['mainText'] and self.slideInfo['explText']:
            imageSize = 5
        elif self.slideInfo['mainText'] and not self.slideInfo['explText']:
            imageSize = 6
        elif not self.slideInfo['mainText'] and self.slideInfo['explText']:
            imageSize = 7
        else:
            imageSize = 9
        if self.slideInfo['explImage'] or isExpl:
            imageSize -= 1
        imageSize -= 1
        imageSize = str(imageSize)

        self.writeTeX([
            '%% Section ' + (obj.title or "main"),
            '\\begin{tabular}{ll}',
        ])

        # Slide text
        if haveText:
            self.writeTeX([
                '\\begin{minipage}{' + ('0.58' if haveImage else '0.97') + '\\textwidth}',
                '{\\scriptsize' if isExpl else '',
                '\\vfill' if isExpl else '',
                obj.text,
                '}' if isExpl else '',
                '\\end{minipage}',
            ])

        # Slide image
        if haveImage:
            tf = ScriptToTeX()
            data = tf.convert(
                obj.image_code.raw,
                datastream("scriptToImage"),
                mimetype='text/x-uri' if obj.image_code.mimeType == 'text/x-url' else obj.image_code.mimeType)

            self.writeTeX([
                '\\hspace{0.5mm}',
                '\\begin{minipage}{' + ('0.38' if haveText else '0.97') + '\\textwidth}',
                '\\begin{figure}',
                data.getData(),
                '\\caption{\scriptsize ' + obj.image_caption + '}' if obj.image_caption else '',
                '\\end{figure}',
                '\\end{minipage}',
            ])

        self.writeTeX([
            '\\end{tabular}',
        ])
Ejemplo n.º 38
0
 def _wrap(self, name):
     """wrap a data object in an icache"""
     return datastream(name)
Ejemplo n.º 39
0
 def test_shortcodehtml2html(self):
     html = open(os.path.join(dirname, 'test.html')).read()
     transform = shortcodehtml_to_html()
     data = datastream(html)
     data = transform.convert(html, data) 
Ejemplo n.º 40
0
 def _wrap(self, name):
     """wrap a data object in an icache"""
     return datastream(name)
Ejemplo n.º 41
0
 def convertTo(self, target_mimetype, orig, data=None, object=None, **kwargs):
     assert orig == self.expected, '????'
     if data is None:
         data = datastream('test')
     data.setData(orig)
     return data