Example #1
0
    def save_xml(cls, port, path):
        """
        This method save the port in user space.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """
        port.source = "xml"
        parser = XMLParser()
        parser.addTag(tag_name)

        parser.setTagAttr(tag_name, 'type', port.type)
        parser.setTagAttr(tag_name, 'language', port.language)
        parser.setTagAttr(tag_name, 'hint', port.hint)
        parser.setTagAttr(tag_name, 'color', port.color)
        parser.setTagAttr(tag_name, 'multiple', port.multiple)
        parser.setTagAttr(tag_name, 'var_name', port.var_name)
        parser.appendToTag(tag_name, 'code').string = str(port.code)

        if not Persistence.create_dir(path):
            return False
        try:
            file_name = port.hint
            port_file = file(os.path.join(path, file_name + '.xml'), 'w')
            port_file.write(parser.prettify())
            port_file.close()
        except IOError as e:
            return False
        return True
Example #2
0
    def save_xml(cls, code_template, path):
        """
        This method save the code_template in user space.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """
        code_template.source = "xml"
        parser = XMLParser()
        parser.addTag(CodeTemplatePersistence.tag_name)

        for prop in CodeTemplatePersistence.properties:
            if hasattr(code_template, prop):
                parser.setTagAttr(CodeTemplatePersistence.tag_name, prop,
                                  code_template.__dict__[prop])

        parser.appendToTag(CodeTemplatePersistence.tag_name, 'code_parts')
        for key in code_template.code_parts:
            parser.appendToTag('code_parts', 'code_part', value=key.strip())

        if not Persistence.create_dir(path):
            return False
        try:
            file_name = code_template.name
            code_template_file = file(os.path.join(path, file_name + '.xml'),
                                      'w')
            code_template_file.write(parser.prettify())
            code_template_file.close()
        except IOError as e:
            return False
        return True
Example #3
0
    def save(cls, port):
        """
        This method save the port in user space.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """
        from mosaicode.system import System
        port.source = "xml"
        parser = XMLParser()
        parser.addTag(tag_name)

        parser.setTagAttr(tag_name, 'type', port.type)
        parser.setTagAttr(tag_name, 'language', port.language)
        parser.setTagAttr(tag_name, 'label', port.label)
        parser.setTagAttr(tag_name, 'color', port.color)
        parser.setTagAttr(tag_name, 'multiple', port.multiple)
        parser.setTagAttr(tag_name, 'source', port.source)
        parser.appendToTag(tag_name, 'code').string = str(port.code)

        count = 0
        for code in port.input_codes:
            parser.appendToTag(tag_name, 'input_code' + \
                        str(count)).string = str(port.input_codes[count])
            parser.appendToTag(tag_name, 'output_code' + \
                        str(count)).string = str(port.output_codes[count])
            count = count + 1


        try:
            data_dir = System.get_user_dir() + "/extensions/"
            data_dir = data_dir + port.language + "/ports/"
            if not os.path.isdir(data_dir):
                try:
                    os.makedirs(data_dir)
                except:
                    pass
            file_name = data_dir + port.type + ".xml"
            port_file = file(os.path.expanduser(file_name), 'w')
            port_file.write(parser.prettify())
            port_file.close()
        except IOError as e:
            return False
        return True
Example #4
0
    def save(cls, code_template):
        """
        This method save the code_template in user space.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """
        from mosaicode.system import System
        code_template.source = "xml"
        parser = XMLParser()
        parser.addTag('MosaicodeCodeTemplate')
        parser.setTagAttr('MosaicodeCodeTemplate', 'name', code_template.name)
        parser.setTagAttr('MosaicodeCodeTemplate', 'type', code_template.type)
        parser.setTagAttr('MosaicodeCodeTemplate', 'description',
                          code_template.description)
        parser.setTagAttr('MosaicodeCodeTemplate', 'language',
                          code_template.language)
        parser.setTagAttr('MosaicodeCodeTemplate', 'extension',
                          code_template.extension)
        parser.setTagAttr('MosaicodeCodeTemplate', 'source',
                          code_template.source)
        parser.appendToTag('MosaicodeCodeTemplate',
                           'command').string = str(code_template.command)
        parser.appendToTag('MosaicodeCodeTemplate',
                           'code').string = str(code_template.code)

        try:
            data_dir = System.get_user_dir() + "/extensions/"
            data_dir = data_dir + code_template.language + "/"
            if not os.path.isdir(data_dir):
                try:
                    os.makedirs(data_dir)
                except:
                    pass
            file_name = data_dir + code_template.type + ".xml"
            code_template_file = file(os.path.expanduser(file_name), 'w')
            code_template_file.write(parser.prettify())
            code_template_file.close()
        except IOError as e:
            return False
        return True
    def save_xml(cls, code_template, path):
        """
        This method save the code_template in user space.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """
        code_template.source = "xml"
        parser = XMLParser()
        parser.addTag(tag_name)

        parser.setTagAttr(tag_name, 'name', code_template.name)
        parser.setTagAttr(tag_name, 'type', code_template.type)
        parser.setTagAttr(tag_name, 'description', code_template.description)
        parser.setTagAttr(tag_name, 'language', code_template.language)
        parser.setTagAttr(tag_name, 'command', code_template.command)

        parser.appendToTag(tag_name, 'code_parts')
        for key in code_template.code_parts:
            parser.appendToTag('code_parts', 'code_part', value=key.strip())

        parser.appendToTag(tag_name, 'files')
        for key in code_template.files:
            parser.appendToTag('files',
                               'file',
                               name_=key,
                               value=code_template.files[key])

        parser.appendToTag(tag_name, 'properties')
        for key in code_template.properties:
            parser.appendToTag('properties', 'property', value=key)

        if not Persistence.create_dir(path):
            return False
        try:
            file_name = code_template.name
            code_template_file = file(os.path.join(path, file_name + '.xml'),
                                      'w')
            code_template_file.write(parser.prettify())
            code_template_file.close()
        except IOError as e:
            from mosaicode.system import System
            System()
            System.log(e)
            return False
        return True
Example #6
0
    def save_xml(cls, block, path):
        """
        This method save the block in user space.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """

        block.source = "xml"
        parser = XMLParser()
        main = parser.addTag(tag_name)
        parser.setTagAttr(tag_name,'type', block.type)
        parser.setTagAttr(tag_name,'language', block.language)
        parser.setTagAttr(tag_name,'framework', block.framework)

        parser.setTagAttr(tag_name,'label', block.label)
        parser.setTagAttr(tag_name,'group', block.group)
        parser.setTagAttr(tag_name,'color', block.color)
        parser.setTagAttr(tag_name,'help', block.help)

        for code in block.codes:
            parser.appendToTag(tag_name, code, value=block.codes[code])

        parser.appendToTag(tag_name, 'properties')
        for key in block.properties:
            parser.appendToTag('properties', 'property', value=key)

        parser.appendToTag(tag_name, 'ports')
        for port in block.ports:
            parser.appendToTag('ports', 'port',
                conn_type=port.conn_type,
                name_=port.name,
                label=port.label,
                type_=port.type)

        if not Persistence.create_dir(path):
            return False
        try:
            file_name = path + block.type + ".xml"
            block_file = file(os.path.expanduser(file_name), 'w')
            block_file.write(parser.getXML())
            block_file.close()
        except IOError as e:
            return False
        return True
Example #7
0
    def save(cls, diagram):
        """
        This method save a file.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """
        parser = XMLParser()
        parser.addTag(tag_name)
        parser.setTagAttr(tag_name, 'version', value=System.VERSION)
        parser.setTagAttr(tag_name, 'zoom', value=diagram.zoom)
        parser.setTagAttr(tag_name, 'language', value=diagram.language)

        parser.appendToTag(tag_name,
                           'code_template',
                           value=diagram.code_template)

        parser.appendToTag(tag_name, 'blocks')
        for block_id in diagram.blocks:
            block = diagram.blocks[block_id]
            pos = block.get_position()
            parser.appendToTag('blocks',
                               'block',
                               type=block.type,
                               id=block.id,
                               collapsed=block.is_collapsed,
                               x=pos[0],
                               y=pos[1])
            props = block.get_properties()
            for prop in props:
                parser.appendToLastTag('block',
                                       'property',
                                       key=str(prop["name"]),
                                       value=str(prop["value"]))

        parser.appendToTag(tag_name, 'connections')
        for connector in diagram.connectors:
            parser.appendToTag('connections',
                               'connection',
                               from_block=connector.output.id,
                               from_out=int(connector.output_port.index),
                               to_block=connector.input.id,
                               to_in=int(connector.input_port.index))

        parser.appendToTag(tag_name, 'comments')
        for comment in diagram.comments:
            pos = comment.get_position()
            parser.appendToTag('comments', 'comment', x=pos[0], y=pos[1])
            props = comment.get_properties()
            for prop in props:
                parser.appendToLastTag('comment',
                                       'property',
                                       key=str(prop["name"]),
                                       value=str(prop["value"]))

        auth = AuthorModel()
        auth.name = System.get_preferences().author
        auth.license = System.get_preferences().license
        auth.date = datetime.now()
        diagram.authors.insert(0, auth)

        parser.appendToTag(tag_name, 'authors')
        for author in diagram.authors:
            parser.appendToTag('authors',
                               'author',
                               author=author.name,
                               license=author.license,
                               date=author.date)

        try:
            save_file = open(str(diagram.file_name), "w")
            save_file.write(parser.prettify())
            save_file.close()
        except IOError as e:
            System.log(e.strerror)
            return False, e.strerror

        diagram.set_modified(False)
        return True, "Success"
    def save_xml(cls, block, path=None):
        """
        This method save the block in user space.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """

        block.source = "xml"
        parser = XMLParser()
        main = parser.addTag(tag_name)
        parser.setTagAttr(tag_name, 'type', block.type)
        parser.setTagAttr(tag_name, 'language', block.language)
        parser.setTagAttr(tag_name, 'extension', block.extension)

        parser.setTagAttr(tag_name, 'help', block.help)
        parser.setTagAttr(tag_name, 'label', block.label)
        parser.setTagAttr(tag_name, 'color', block.color)
        parser.setTagAttr(tag_name, 'group', block.group)

        parser.appendToTag(tag_name, 'codes')
        for key in block.codes:
            parser.appendToTag(
                    'codes',
                    'code',
                    name_=key,
                    value=block.codes[key]
                    )

        parser.appendToTag(tag_name, 'properties')
        for key in block.properties:
            parser.appendToTag('properties', 'property', value=key)

        parser.appendToTag(tag_name, 'ports')
        for port in block.ports:
            parser.appendToTag(
                        'ports',
                        'port',
                        conn_type=port.conn_type,
                        name_=port.name,
                        label=port.label,
                        type_=port.type
                        )

        if (path is not None) and not Persistence.create_dir(path):
            return False

        if (path is None) and (block.file is not None):
            path = block.file
        elif (path is not None):
            file_name = block.label
            path = os.path.join(path, file_name + '.xml')
        else:
            return False

        try:
            block_file = open(path, 'w')
            block_file.write(parser.getXML())
            block_file.close()
        except IOError as e: 
            return False
        return True
Example #9
0
class TestXMLParser(TestCase):
    def setUp(self):
        """Do the test basic setup."""
        source = None
        fromString = False
        fromTag = False
        self.xml_parser = XMLParser(source, fromString, fromTag)

        source = FILES_INPUT + "And.mscd"
        fromString = False
        fromTag = False
        self.xml_parser = XMLParser(source, fromString, fromTag)

        # source = FILES_INPUT + "And.mscd"
        # fromString = True
        # fromTag = False
        # self.xml_parser = XMLParser(source, fromString, fromTag)
        #
        # source = "TESTE"
        # fromString = True
        # fromTag = False
        # self.xml_parser = XMLParser(source, fromString, fromTag)
        #
        # source = "TESTE"
        # fromString = False
        # fromTag = True
        # self.xml_parser = XMLParser(source, fromString, fromTag)
        #
        # source = "TESTE"
        # fromString = True
        # fromTag = True
        # self.xml_parser = XMLParser(source, fromString, fromTag)

    # ----------------------------------------------------------------------
    def test_getTagAttr(self):
        self.xml_parser.tag = "property"
        self.xml_parser.attr = "key"
        self.assertIsNotNone(
            self.xml_parser.getTagAttr(self.xml_parser.tag,
                                       self.xml_parser.attr))

        #tag = None
        #attr = None
        #self.assertIsNotNone(self.xml_parser.getTagAttr(tag, attr))

    # ----------------------------------------------------------------------
    def test_setTagAttr(self):
        tag = "position"
        attr = "x"
        self.assertIsNone(self.xml_parser.setTagAttr(tag, attr, 10))

    # ----------------------------------------------------------------------
    def test_getAttr(self):
        #tag = "position"
        attr = "position"
        self.assertIsNotNone(self.xml_parser.getAttr(attr))
        #self.assertEqual(10, self.xml_parser.setTagAttr(attr))

    # ----------------------------------------------------------------------
    def test_setAttr(self):
        attr = "to_block"
        self.assertIsNone(self.xml_parser.setAttr(attr, 10))

    # ----------------------------------------------------------------------
    def test_getChildTagAttr(self):
        parent = "block"
        child = "position"
        attr = "x"
        self.assertIsNotNone(
            self.xml_parser.getChildTagAttr(parent, child, attr))

    # ----------------------------------------------------------------------
    def test_setChildTagAttr(self):
        parent = "block"
        child = "position"
        attr = "x"
        value = 10
        self.assertIsNone(
            self.xml_parser.setChildTagAttr(parent, child, attr, value))

    # ----------------------------------------------------------------------
    def test_getChildTags(self):
        child = "position"
        self.assertIsNotNone(self.xml_parser.getChildTags(child))
        child = "block"
        self.assertIsNotNone(self.xml_parser.getChildTags(child))

    # ----------------------------------------------------------------------
    def test_addTag(self):
        tagName = "position"
        self.assertIsNotNone(self.xml_parser.addTag(tagName))

    # ----------------------------------------------------------------------
    def test_appendToTag(self):
        tagParent = "position"
        tagChild = "x"
        self.assertIsNotNone(self.xml_parser.appendToTag(tagParent, tagChild))

    # ----------------------------------------------------------------------
    def test_appendToLastTag(self):
        tagParent = "position"
        tagChild = "x"
        self.assertIsNotNone(
            self.xml_parser.appendToLastTag(tagParent, tagChild))

    # ----------------------------------------------------------------------
    def test_getXML(self):
        self.assertIsNotNone(self.xml_parser.getXML())

    # ----------------------------------------------------------------------
    def test_getTagXML(self):
        tagName = "position"
        tag = self.xml_parser.addTag(tagName)
        self.assertIsNotNone(self.xml_parser.getTagXML(tag))

    # ----------------------------------------------------------------------
    def test_getTag(self):
        tagName = "position"
        tag = self.xml_parser.addTag(tagName)
        self.assertIsNone(self.xml_parser.getTag(tag))
        tag = "ABC"
        self.assertIsNone(self.xml_parser.getTag(tag))
        tag = "position"
        self.assertIsNotNone(self.xml_parser.getTag(tag))

    # ----------------------------------------------------------------------
    def test_getTagChild(self):
        parent = "block"
        child = "position"
        self.assertIsNotNone(self.xml_parser.getTagChild(parent, child))

    # ----------------------------------------------------------------------
    def test_getTagContent(self):
        self.assertIsNotNone(self.xml_parser.getTagContent())

    # ----------------------------------------------------------------------
    def test_getTagChildren(self):
        self.assertIsNotNone(self.xml_parser.getTagChildren())

    # ----------------------------------------------------------------------
    def test_getText(self):
        self.assertIsNotNone(self.xml_parser.getText())

    # ----------------------------------------------------------------------
    def test_prettify(self):
        self.assertIsNotNone(self.xml_parser.prettify())
Example #10
0
    def save(cls, prefs, path):
        """
        This method save the diagram.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """
        parser = XMLParser()
        parser.addTag(tag_name)

        parser.setTagAttr(tag_name,'author', prefs.author)
        parser.setTagAttr(tag_name,'license', prefs.license)

        parser.setTagAttr(tag_name,'default_directory', prefs.default_directory)
        parser.setTagAttr(tag_name,'default_filename', prefs.default_filename)
        parser.setTagAttr(tag_name,'grid', prefs.grid)
        parser.setTagAttr(tag_name, 'network_port', prefs.port)
        parser.setTagAttr(tag_name,'width', prefs.width)
        parser.setTagAttr(tag_name,'height', prefs.height)
        parser.setTagAttr(tag_name,'hpaned_work_area', prefs.hpaned_work_area)
        parser.setTagAttr(tag_name,'vpaned_bottom', prefs.vpaned_bottom)
        parser.setTagAttr(tag_name,'vpaned_left', prefs.vpaned_left)

        parser.appendToTag(tag_name, 'recent_files')
        for key in prefs.recent_files:
            parser.appendToTag('recent_files', 'name', value=key)

        try:
            file_name = path + "/" + prefs.conf_file_path
            confFile = file(os.path.expanduser(file_name), 'w')
            confFile.write(parser.prettify())
            confFile.close()
        except IOError as e:
            return False
        return True
Example #11
0
    def save(cls, plugin):
        """
        This method save the plugin in user space.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """
        from mosaicode.system import System
        plugin.source = "xml"
        parser = XMLParser()
        main = parser.addTag('MosaicodePlugin')
        parser.setTagAttr('MosaicodePlugin','type', plugin.type)
        parser.setTagAttr('MosaicodePlugin','language', plugin.language)
        parser.setTagAttr('MosaicodePlugin','framework', plugin.framework)

        parser.setTagAttr('MosaicodePlugin','label', plugin.label)
        parser.setTagAttr('MosaicodePlugin','group', plugin.group)
        parser.setTagAttr('MosaicodePlugin','color', plugin.color)
        parser.setTagAttr('MosaicodePlugin','help', plugin.help)
        parser.setTagAttr('MosaicodePlugin','source', plugin.source)

        count = 0
        for code in plugin.codes:
            parser.appendToTag('MosaicodePlugin', 'code' + str(count)).string = str(plugin.codes[count])
            count = count + 1

        parser.appendToTag('MosaicodePlugin', 'properties')
        for key in plugin.properties:
            parser.appendToTag('properties', 'property', value=key)

        parser.appendToTag('MosaicodePlugin', 'in_ports')
        for key in plugin.in_ports:
            parser.appendToTag('in_ports', 'port', value=key)

        parser.appendToTag('MosaicodePlugin', 'out_ports')
        for key in plugin.out_ports:
            parser.appendToTag('out_ports', 'port', value=key)

        try:
            data_dir = System.get_user_dir() + "/extensions/"
            data_dir = data_dir + plugin.language + "/" + plugin.framework + "/"
            if not os.path.isdir(data_dir):
                try:
                    os.makedirs(data_dir)
                except:
                    pass
            file_name = data_dir + plugin.type + ".xml"
            plugin_file = file(os.path.expanduser(file_name), 'w')
            plugin_file.write(parser.getXML())
            plugin_file.close()
        except IOError as e:
            return False
        return True
Example #12
0
    def save(cls, block):
        """
        This method save the block in user space.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """

        from mosaicode.system import System
        block.source = "xml"
        parser = XMLParser()
        main = parser.addTag(tag_name)
        parser.setTagAttr(tag_name,'type', block.type)
        parser.setTagAttr(tag_name,'language', block.language)
        parser.setTagAttr(tag_name,'framework', block.framework)

        parser.setTagAttr(tag_name,'label', block.label)
        parser.setTagAttr(tag_name,'group', block.group)
        parser.setTagAttr(tag_name,'color', block.color)
        parser.setTagAttr(tag_name,'help', block.help)

        for code in block.codes:
            parser.appendToTag(tag_name, code, value=block.codes[code])

        parser.appendToTag(tag_name, 'properties')
        for key in block.properties:
            parser.appendToTag('properties', 'property', value=key)

        parser.appendToTag(tag_name, 'ports')
        for port in block.ports:
            parser.appendToTag('ports', 'port',
                conn_type=port.conn_type,
                name_=port.name,
                label=port.label,
                type_=port.type)

        try:
            data_dir = System.get_user_dir() + "/extensions/"
            data_dir = data_dir + block.language + "/" + block.framework + "/"
            if not os.path.isdir(data_dir):
                try:
                    os.makedirs(data_dir)
                except:
                    pass
            file_name = data_dir + block.type + ".xml"
            block_file = file(os.path.expanduser(file_name), 'w')
            block_file.write(parser.getXML())
            block_file.close()
        except IOError as e:
            return False
        return True
    def save(cls, prefs):
        """
        This method save the diagram.

        Returns:

            * **Types** (:class:`boolean<boolean>`)
        """
        parser = XMLParser()
        parser.addTag('MosaicodeProperties')
        parser.setTagAttr('MosaicodeProperties','default_directory',
                prefs.default_directory)
        parser.setTagAttr('MosaicodeProperties','default_filename',
                prefs.default_filename)
        parser.setTagAttr('MosaicodeProperties','grid', prefs.grid)
        parser.setTagAttr('MosaicodeProperties','width', prefs.width)
        parser.setTagAttr('MosaicodeProperties','height', prefs.height)
        parser.setTagAttr('MosaicodeProperties','hpaned_work_area',
                prefs.hpaned_work_area)
        parser.setTagAttr('MosaicodeProperties','vpaned_bottom',
                prefs.vpaned_bottom)
        parser.setTagAttr('MosaicodeProperties','vpaned_left',
                prefs.vpaned_left)

        parser.appendToTag('MosaicodeProperties', 'recent_files')
        for key in prefs.recent_files:
            parser.appendToTag('recent_files', 'name', value=key)

        try:
            from mosaicode.system import System
            file_name = System.get_user_dir() + "/" + prefs.conf_file_path
            confFile = file(os.path.expanduser(file_name), 'w')
            confFile.write(parser.prettify())
            confFile.close()
        except IOError as e:
            return False
        return True