nymea/plugins/guh-generateplugininfo

#!/usr/bin/env python

# -*- coding: UTF-8 -*-

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#                                                                         #
#  Copyright (C) 2015 Simon Stuerz <simon.stuerz@guh.guru>                #
#  Copyright (C) 2014 Michael Zanetti <michael_zanetti@gmx.net>           #
#                                                                         #
#  This file is part of guh-cli.                                          #
#                                                                         #
#  guh-cli is free software: you can redistribute it and/or modify        #
#  it under the terms of the GNU General Public License as published by   #
#  the Free Software Foundation, version 2 of the License.                #
#                                                                         #
#  guh-cli is distributed in the hope that it will be useful,             #
#  but WITHOUT ANY WARRANTY; without even the implied warranty of         #
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the           #
#  GNU General Public License for more details.                           #
#                                                                         #
#  You should have received a copy of the GNU General Public License      #
#  along with guh. If not, see <http://www.gnu.org/licenses/>.            #
#                                                                         #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

import argparse
import traceback
import json
import sys

__version__="1.0.0"

parser = argparse.ArgumentParser(description='The guh-generateplugininfo is a precompiler for building plugins. This precompiler will create a plugininfo.h containing the uuid definitions from the plugin json file.')
parser.add_argument("input", help="The JSON input file with the plugin description")
parser.add_argument("output", help="The plugininfo.h outputfile file with the uuid declarations")
parser.add_argument('-v','--version', action='version', version=__version__)
args = parser.parse_args()

inputFile = open(args.input, "r")
outputfile = open(args.output, "w")
outputfile2 = open("extern-" + args.output, "w")

print "%s -> %s" %(args.input, args.output)

variableNames = []
externDefinitions = []

try:
    pluginMap = json.loads(inputFile.read())
except ValueError as e:
    print " --> Error loading input file \"%s\"" % (sys.argv[1])
    print "     %s" % (e)
    exit -1


def writePluginInfo(line):
    outputfile.write("%s\n" % line)


def writeExternPluginInfo(line):
    outputfile2.write("%s\n" % line)


def extractVendors(pluginMap):
    for vendor in pluginMap['vendors']:
        try:
            print("define VendorId %sVendorId = %s" % (pluginMap["idName"], vendor["id"]))
            writePluginInfo("VendorId %sVendorId = VendorId(\"%s\");" % (vendor["idName"], vendor["id"]))
            createExternDefinition("VendorId", "%sVendorId" % (vendor["idName"]))
        except:
            pass
        extractDeviceClasses(vendor)


def extractDeviceClasses(vendorMap):
    for deviceClass in vendorMap["deviceClasses"]:
        try:
            variableName = "%sDeviceClassId" % (deviceClass["idName"]) 
            if not variableName in variableNames:
                variableNames.append(variableName)
                print("define DeviceClassId %s = %s" % (variableName, deviceClass["deviceClassId"]))
                writePluginInfo("DeviceClassId %s = DeviceClassId(\"%s\");" % (variableName, deviceClass["deviceClassId"]))
                createExternDefinition("DeviceClassId", variableName)
            else:
                print("duplicated variable name \"%s\" for DeviceClassId %s -> skipping") % (variableName, deviceClass["deviceClassId"])
        except:
            pass
        extractActionTypes(deviceClass)
        extractStateTypes(deviceClass)
        extractEventTypes(deviceClass)


def extractStateTypes(deviceClassMap):
    try:
        for stateType in deviceClassMap["stateTypes"]:
            try:
                variableName = "%sStateTypeId" % (stateType["idName"])
                if not variableName in variableNames:
                    variableNames.append(variableName)
                    print("define StateTypeId %s = %s" % (variableName, stateType["id"]))
                    writePluginInfo("StateTypeId %s = StateTypeId(\"%s\");" % (variableName, stateType["id"]))
                    createExternDefinition("StateTypeId", variableName)
                else:
                    print("duplicated variable name \"%s\" for StateTypeId %s -> skipping") % (variableName, stateType["id"])
                # create ActionTypeId if the state is writable
                if 'writable' in stateType:
                    if stateType['writable']:
                        vName = "%sActionTypeId" % (stateType["idName"]) 
                        if not vName in variableNames:
                            variableNames.append(vName)
                            print("define ActionTypeId %s for writable StateType %s = %s" % (vName, variableName, stateType["id"]))
                            writePluginInfo("ActionTypeId %s = ActionTypeId(\"%s\");" % (vName, stateType["id"]))
                            createExternDefinition("ActionTypeId", vName)
                        else:
                            print("duplicated variable name \"%s\" for ActionTypeId %s -> skipping") % (variableName, stateType["id"])
            except:
                pass
    except:
        pass


def extractActionTypes(deviceClassMap):
    try:
        for actionType in deviceClassMap["actionTypes"]:
            try:
                variableName = "%sActionTypeId" % (actionType["idName"])
                if not variableName in variableNames:
                    variableNames.append(variableName)
                    writePluginInfo("ActionTypeId %s = ActionTypeId(\"%s\");" % (variableName, actionType["id"]))
                    createExternDefinition("ActionTypeId", variableName)
                else:
                    print("duplicated variable name \"%s\" for ActionTypeId %s -> skipping") % (variableName, actionType["id"])
            except:
                pass
    except:
        pass


def extractEventTypes(deviceClassMap):
    try:
        for eventType in deviceClassMap["eventTypes"]:
            try:
                variableName = "%sEventTypeId" % (eventType["idName"])
                if not variableName in variableNames:
                    variableNames.append(variableName)
                    writePluginInfo("EventTypeId %s = EventTypeId(\"%s\");" % (variableName, eventType["id"]))
                    createExternDefinition("EventTypeId", variableName)                    
                else:
                    print("duplicated variable name \"%s\" for EventTypeId %s -> skipping") % (variableName, eventType["id"])
            except:
                pass
    except:
        pass

def createExternDefinition(type, name):
    definition = {}
    definition['type'] = type
    definition['variable'] = name
    externDefinitions.append(definition)


##################################################################################################################
# write plugininfo.h
print " --> generate plugininfo.h"
print "PluginId for plugin \"%s\" = %s" %(pluginMap['name'], pluginMap['id'])
    
writePluginInfo("/* This file is generated by the guh build system. Any changes to this file will")
writePluginInfo(" * be lost.")
writePluginInfo(" *")
writePluginInfo(" * If you want to change this file, edit the plugin's json file and add")
writePluginInfo(" * idName tags where appropriate.")
writePluginInfo(" */")
writePluginInfo("")
writePluginInfo("#ifndef PLUGININFO_H")
writePluginInfo("#define PLUGININFO_H")
writePluginInfo("#include \"typeutils.h\"")
writePluginInfo("#include <QLoggingCategory>")
writePluginInfo("")
writePluginInfo("// Id definitions")
writePluginInfo("PluginId pluginId = PluginId(\"%s\");" % pluginMap['id'])

extractVendors(pluginMap)
writePluginInfo("")
writePluginInfo("// Loging category")

if 'idName' in pluginMap:
    writePluginInfo("Q_DECLARE_LOGGING_CATEGORY(dc%s)" % pluginMap['idName'])
    writePluginInfo("Q_LOGGING_CATEGORY(dc%s, \"%s\")" % (pluginMap['idName'], pluginMap['idName']))
    print "define logging category: \"dc%s\"" % pluginMap['idName']
    
writePluginInfo("")
writePluginInfo("#endif // PLUGININFO_H")
print " --> generated successfully \"%s\"" % sys.argv[2] 


##################################################################################################################
# write extern-plugininfo.h 
print " --> generate extern-plugininfo.h"
writeExternPluginInfo("/* This file is generated by the guh build system. Any changes to this file will")
writeExternPluginInfo(" * be lost.")
writeExternPluginInfo(" *")
writeExternPluginInfo(" * If you want to change this file, edit the plugin's json file and add")
writeExternPluginInfo(" * idName tags where appropriate.")
writeExternPluginInfo(" */")
writeExternPluginInfo("")
writeExternPluginInfo("#ifndef EXTERNPLUGININFO_H")
writeExternPluginInfo("#define EXTERNPLUGININFO_H")
writeExternPluginInfo("#include \"typeutils.h\"")
writeExternPluginInfo("#include <QLoggingCategory>")
writeExternPluginInfo("")
writeExternPluginInfo("// Id definitions")

for externDefinition in externDefinitions:
    writeExternPluginInfo("extern %s %s;" % (externDefinition['type'], externDefinition['variable']))

writeExternPluginInfo("")
writeExternPluginInfo("// Logging category definition")

if 'idName' in pluginMap:
    writeExternPluginInfo("Q_DECLARE_LOGGING_CATEGORY(dc%s)" % pluginMap['idName'])
    
writeExternPluginInfo("")
writeExternPluginInfo("#endif // EXTERNPLUGININFO_H")

print " --> generated successfully \"extern-%s\"" % (sys.argv[2])