Example #1
0
def main():
    args = parse_args()
    config = util.load_yaml(args.config)
    files = util.input_files(args.files)
    lang = language.get(args.lang, None)["TypeMap"]

    files.extend([f"{PRESTO_HOME}/{file}" for file in config.JavaClasses])

    classes = defaultdict(util.attrdict)
    depends = defaultdict(set)

    subclasses = {}
    for abstract_name, abstract_value in config.AbstractClasses.items():

        classes[abstract_name].class_name = abstract_name
        classes[abstract_name].field_name = member_name(abstract_name)
        classes[abstract_name].abstract = True
        classes[abstract_name].super_class = abstract_value.super
        if "comparable" in abstract_value:
            classes[abstract_name].comparable = True
        classes[abstract_name].subclasses = []

        for subclass in abstract_value.subclasses:
            subclasses[subclass.name] = util.attrdict(super=abstract_name,
                                                      key=subclass.key)

            classes[abstract_name].subclasses.append(
                util.attrdict(
                    type=subclass.name,
                    name=member_name(subclass.name),
                    key=subclass.key,
                ))
            classes[abstract_name].subclasses[-1]._N = len(
                classes[abstract_name].subclasses)

        classes[abstract_name].subclasses[-1]._last = True

        if "source" in abstract_value:
            file = abstract_value.source
            process_file(f"{PRESTO_HOME}/{file}", config, lang, subclasses,
                         classes, depends)
        else:
            classes[abstract_name].fields = []
            add_extra(abstract_name, abstract_name, config, lang, classes,
                      depends)

    for file in files:
        process_file(file, config, lang, subclasses, classes, depends)

    depends = list(topological({k: list(v) for k, v in depends.items()}))[::-1]

    comment = "// This file is generated DO NOT EDIT @" + "generated"
    result = [{"comment": comment}]
    result += [classes[name] for name in depends if name in classes]
    result += [classes[name] for name in config.AddToOutput]

    if args.json:
        print(util.to_json(result))
Example #2
0
    def make_call(self, method, url, payload=None):
        if payload:
            enc_payload = simplejson.dumps(payload)
        else:
            enc_payload = ""

        response = requests.request(method, self.baseuri+url, data=enc_payload, auth=self.auth())
        response_body = simplejson.loads(response.text)
        #print response_body
        if response.status_code not in (200, 201):
            raise GithubV3APIError(response.status_code, response_body['message'], response_body)
        return attrdict(response_body)
Example #3
0
    def make_call(self, method, url, payload=None):
        if payload:
            enc_payload = simplejson.dumps(payload)
        else:
            enc_payload = ""

        response = requests.request(method, self.baseuri + url, data=enc_payload, auth=self.auth())
        response_body = simplejson.loads(response.text)
        # print response_body
        if response.status_code not in (200, 201):
            raise GithubV3APIError(response.status_code, response_body["message"], response_body)
        return attrdict(response_body)
Example #4
0
def add_field(current_class, filename, field_name, field_type, config, lang,
              classes, depends):
    if filename in config.EnumMap and field_type in config.EnumMap[filename]:
        field_type = config.EnumMap[filename][field_type]

    field_flag = {}
    field_text = field_type

    field_local = True
    if "super_class" in classes[current_class]:
        super = classes[classes[current_class].super_class]
        if "fields" in super:
            if (len(
                    list(
                        filter(lambda x: x.field_name == field_name,
                               super.fields))) != 0):
                field_local = False

    for key, value in lang.items():
        if type(value) == str:
            field_text = regex.sub(key, value, field_text)
        else:
            field_text, n = regex.subn(key, value["replace"], field_text)
            if n > 0:
                if value["flag"]:
                    field_flag.update(value["flag"])

    classes[current_class].fields.append(
        util.attrdict(field_type=field_type,
                      field_name=field_name,
                      field_text=field_text))
    classes[current_class].fields[-1].update(field_flag)
    classes[current_class].fields[-1]._N = len(classes[current_class].fields)
    if current_class == field_type:
        classes[current_class].fields[-1].optional = True
    classes[current_class].fields[-1].field_local = field_local

    if (field_type in classes and "abstract" in classes[field_type]
            and classes[field_type].abstract):
        classes[current_class].fields[-1].optional = True

    types = set(regex.sub("[^a-zA-Z0-9_]+", " ", field_type).split())
    types.discard(current_class)
    depends[current_class].update(types)
Example #5
0
               float:    Symbol("s", "number"),
               str:      Symbol("s", "text"),
               Symbol:   Symbol("s", "symbol"),
               Location: Symbol("s", "location")}

class NoSuchLocationError(Exception):
    pass

class UndefinedDocError(Exception):
    pass

# {{{ notify = 
notify = attrdict(valueChanged = Symbol("", "value-changed"),
                  addProperty = Symbol("", "add-property"),
                  delProperty = Symbol("", "del-property"),
                  addSlice = Symbol("", "add-slice"),
                  delSlice = Symbol("", "del-slice"),
                  tagChanged = Symbol("", "tag-changed"),
                  noSuchLocation = Symbol("", "no-such-location"))
# }}}

# {{{ class BaseDoc(object):

# {{{ def strToSymbol(x):
def strToSymbol(x):
    if isinstance(x, str):
        return Symbol("", x)
    else:
        return x
# }}}
    
Example #6
0
Keyboard commands:

    f: Output frames of the OpenGL buffer.
    g: Toggle grid.
    p: Print metadata.
    r: Toggle rotation minimizing frames.
    s: Toggle geometry display (if available).
    t: Toggle turntable.
    x: Toggle origin display.
    z: Reset the view.
    2: Toggle seed path display.
    ?: Print this message.
'''

runner = None
opt = attrdict()
opt.current_frame = 1
opt.frame_format = "out.%04d.png"
opt.history = []
opt.history_max = 256
opt.meta = attrdict()
opt.refresh_rate = int(1000 / 30)
opt.rotate_x = 0.0
opt.rotate_y = 0.2
opt.turntable_rate = math.pi / 10
opt.want_continuous = False
opt.want_frames = False
opt.want_geometry = True
opt.want_grid = True
opt.want_xyz = False
opt.want_history = False
Example #7
0
def process_file(filepath, config, lang, subclasses, classes, depends):
    filename = util.get_filename(filepath)

    if filepath.endswith(".hpp.inc"):
        special(filepath, filename[:-len(".hpp.inc")], "hinc", classes,
                depends)
        return

    if filepath.endswith(".cpp.inc"):
        special(filepath, filename[:-len(".cpp.inc")], "cinc", classes,
                depends)
        return

    fileroot = os.path.splitext(filename)[0]
    current_enum = ""
    current_class = ""
    json = False

    lineno = 1
    for line in preprocess_file(filepath):
        lineno += 1
        fields = line.split()

        if regex.match(r"^ *$", line):
            continue

        # Find any enums in the java class
        #
        match = regex.match(r" *(public|private) enum .*", line)
        if match:
            current_enum = fields[2]

            if fileroot in config.EnumMap and current_enum in config.EnumMap[
                    fileroot]:
                current_enum = config.EnumMap[fileroot][current_enum]

            classes[current_enum].class_name = current_enum
            classes[current_enum].enum = True
            classes[current_enum].elements = []

        if current_enum != "":
            line = regex.sub(r"\([^)]+\)", " ", line)
            fields = line.split()

        match = regex.match(r"^[A-Z0-9_]+[,;]?$", fields[0])
        if current_enum != "" and match:
            line = regex.sub(r"//.*$", "", line)
            line = regex.sub(r"[{;]", "", line)

            names = line.split(",")
            for name in names:
                name = name.strip()
                if name == "":
                    continue

                name = name.split()[0]

                classes[current_enum].elements.append(
                    util.attrdict(element=name))
                classes[current_enum].elements[-1]._N = len(
                    classes[current_enum].elements)

        match = regex.match(r".*;$|^}$|^};$", line)
        if current_enum != "" and match:
            classes[current_enum].elements[-1]._last = True
            current_enum = ""

        # Use the JsonCreator as the definition of a class
        #
        match = regex.match(r".*@JsonCreator.*", line)
        if match:
            json = True

        line = regex.sub(r"[()]", " ", line)
        fields = line.split()

        match = regex.match(r" *public.*", line)
        if json and match:
            current_class = fields[1] if fields[1] != "static" else fields[2]
            classes[current_class].class_name = current_class
            classes[current_class].struct = True
            classes[current_class].fields = []

            if current_class in subclasses:
                classes[current_class].subclass = True
                classes[current_class].super_class = subclasses[
                    current_class].super
                classes[current_class].json_key = subclasses[current_class].key

        match = regex.match(r" *@JsonProperty.*", line)
        if json and match and len(fields) >= 3:
            line = regex.sub(r"^[^@]*", "", line)
            line = regex.sub(r"@Nullable", "", line)
            fields = line.split()
            fields[-1] = regex.sub(r",", "", fields[-1])

            if fields[1][0] == '"':
                type = " ".join(fields[2:-1])
                name = regex.sub('"', "", fields[1])
            else:
                type = " ".join(fields[1:-1])
                name = fields[-1]

            add_field(current_class, fileroot, name, type, config, lang,
                      classes, depends)

        match = regex.match(r" *{ *", line)
        if json and match:
            add_extra(current_class, fileroot, config, lang, classes, depends)

            if len(classes[current_class].fields) == 0:
                classes.pop(current_class)
                json = False
                continue

            json = False

    return classes
Example #8
0
}


class NoSuchLocationError(Exception):
    pass


class UndefinedDocError(Exception):
    pass


# {{{ notify =
notify = attrdict(valueChanged=Symbol("", "value-changed"),
                  addProperty=Symbol("", "add-property"),
                  delProperty=Symbol("", "del-property"),
                  addSlice=Symbol("", "add-slice"),
                  delSlice=Symbol("", "del-slice"),
                  tagChanged=Symbol("", "tag-changed"),
                  noSuchLocation=Symbol("", "no-such-location"))

# }}}

# {{{ class BaseDoc(object):


# {{{ def strToSymbol(x):
def strToSymbol(x):
    if isinstance(x, str):
        return Symbol("", x)
    else:
        return x