From f59403ad72d89d1e7822b0e3df1e310b29390e91 Mon Sep 17 00:00:00 2001 From: Jonathan Bernard Date: Sun, 23 Apr 2023 21:50:30 -0500 Subject: [PATCH] WIP - initial VCard4 implementation. --- src/vcard/vcard4.nim | 1311 ++++++++++++++++++++++++++++++++++++++++++ tests/tvcard4.nim | 9 + 2 files changed, 1320 insertions(+) create mode 100644 src/vcard/vcard4.nim create mode 100644 tests/tvcard4.nim diff --git a/src/vcard/vcard4.nim b/src/vcard/vcard4.nim new file mode 100644 index 0000000..eea6d39 --- /dev/null +++ b/src/vcard/vcard4.nim @@ -0,0 +1,1311 @@ +import std/[genasts, macros, options, sets, streams, strutils, tables, times, unicode] +import zero_functional + +from std/sequtils import toSeq + +import ./private/[common, lexer, util] + +type + VC4_Cardinality = enum + vccAtMostOne, + vccExactlyOne, + vccAtLeastOne + vccAny + + VC4_ValueType = enum + vtText = "text", + vtTextList = "text-list", + vtUri = "uri", + vtDate = "date", + vtTime = "time", + vtDateTime = "date-time", + vtDateAndOrTime = "date-and-or-time", + vtTimestamp = "timestamp", + vtBoolean = "boolean", + vtInteger = "integer", + vtFloat = "float", + vtUtcOffset = "utc-offset", + vtLanguageTag = "language-tag" + + # not in the standard, added to cover common combinations + vtDateTimeOrText = "_date-time-or-text_" + ## used by BDAY and ANNIVERSARY + vtTextOrUri = "_text-or-uri_" + ## used by TEL, UID, and KEY + + VC4_PropertyName = enum + pnSource = "SOURCE", + pnKind = "KIND", + pnXml = "XML", + pnFn = "FN", + pnN = "N", + pnNickname = "NICKNAME", + pnPhoto = "PHOTO", + pnBday = "BDAY", + pnAnniversary = "ANNIVERSARY", + pnGender = "GENDER", + pnAdr = "ADR", + pnTel = "TEL", + pnEmail = "EMAIL", + pnImpp = "IMPP", + pnLang = "LANG", + pnTz = "TZ", + pnGeo = "GEO", + pnTitle = "TITLE", + pnRole = "ROLE", + pnLogo = "LOGO", + pnOrg = "ORG", + pnMember = "MEMBER", + pnRelated = "RELATED", + pnCategories = "CATEGORIES", + pnNote = "NOTE", + pnProdId = "PRODID", + pnRev = "REV", + pnSound = "SOUND", + pnUid = "UID", + pnClientPidMap = "CLIENTPIDMAP", + pnUrl = "URL", + pnVersion = "VERSION", + pnKey = "KEY", + pnFbUrl = "FBURL", + pnCaladrUri = "CALADRURI", + pnCalUri = "CALURI", + + ## Non-standard, added to be a catch-all for non-standard names + pnUnknown = "UNKNOWN" + +const propertyCardMap: Table[VC4_PropertyName, VC4_Cardinality] = [ + (pnSource, vccAny), + (pnKind, vccAtMostOne), + (pnXml, vccAny), + (pnFn, vccAtLeastOne), + (pnN, vccAtMostOne), + (pnNickname, vccAny), + (pnPhoto, vccAny), + (pnBday, vccAtMostOne), + (pnAnniversary, vccAtMostOne), + (pnGender, vccAtMostOne), + (pnAdr, vccAny), + (pnTel, vccAny), + (pnEmail, vccAny), + (pnImpp, vccAny), + (pnLang, vccAny), + (pnTz, vccAny), + (pnGeo, vccAny), + (pnTitle, vccAny), + (pnRole, vccAny), + (pnLogo, vccAny), + (pnOrg, vccAny), + (pnMember, vccAny), + (pnRelated, vccAny), + (pnCategories, vccAny), + (pnNote, vccAny), + (pnProdId, vccAtMostOne), + (pnRev, vccAtMostOne), + (pnSound, vccAny), + (pnUid, vccAtMostOne), + (pnClientPidMap, vccAny), + (pnUrl, vccAny), + (pnVersion, vccExactlyOne), + (pnKey, vccAny), + (pnFbUrl, vccAny), + (pnCaladrUri, vccAny), + (pnCalUri, vccAny) +].toTable() + +const fixedValueTypeProperties = [ + (pnSource, vtUri), + (pnKind, vtText), + (pnXml, vtText), + (pnFn, vtText), + (pnNickname, vtTextList), + (pnPhoto, vtUri), + (pnBday, vtDateTimeOrText), + (pnAnniversary, vtDateTimeOrText), + (pnTel, vtTextOrUri), + (pnEmail, vtText), + (pnImpp, vtUri), + (pnLang, vtText), # technically "language-tag" but the same in function + (pnTz, vtText), # technically "uri" and "utc-offset" are possible value types + # for this as well, but these differences are basically + # ignored by this implementation. The "uri" value type was + # anticipating a standard that never materialized. The + # "utc-offset" value type is not recommended due to the + # realities of Daylight savings time. The actual storage type + # for both of those types in text (UTC offset could arguably + # by an integer, but the format is significant), so users of + # this library will still have access to the data and can + # query the TYPE parameter to decide how to treat it. + (pnGeo, vtUri), + (pnTitle, vtText), + (pnRole, vtText), + (pnLogo, vtUri), + (pnOrg, vtText), + (pnMember, vtUri), + (pnRelated, vtTextOrUri), + (pnCategories, vtTextList), + (pnNote, vtText), + (pnProdId, vtText), + (pnSound, vtUri), + (pnUid, vtTextOrUri), + (pnUrl, vtUri), + (pnVersion, vtText), + (pnKey, vtTextOrUri), + (pnFbUrl, vtUri), + (pnCaladrUri, vtUri), + (pnCalUri, vtUri) +] + +const supportedParameters: Table[string, HashSet[VC4_PropertyName]] = [ + ("LANGUAGE", [pnFn, pnN, pnNickname, pnBday, pnAdr, pnTitle, pnRole, + pnLogo, pnOrg, pnRelated, pnNote, pnSound].toHashSet), + + ("PREF", (propertyCardMap.pairs.toSeq --> + filter(it[1] == vccAtLeastOne or it[1] == vccAny). + map(it[0])). + toHashSet), + + # ("ALTID", all properties), + + ("PID", (propertyCardMap.pairs.toSeq --> + filter((it[1] == vccAtLeastOne or it[1] == vccAny) and + it[0] != pnClientPidMap). + map(it[0])).toHashSet), + + ("TYPE", @[ pnFn, pnNickname, pnPhoto, pnAdr, pnTel, pnEmail, pnImpp, pnLang, + pnTz, pnGeo, pnTitle, pnRole, pnLogo, pnOrg, pnRelated, pnCategories, + pnNote, pnSound, pnUrl, pnKey, pnFburl, pnCaladrUri, pnCalUri ].toHashSet), +].toTable + +const TIMESTAMP_FORMATS = [ + "yyyyMMdd'T'hhmmssZZZ", + "yyyyMMdd'T'hhmmssZZ", + "yyyyMMdd'T'hhmmssZ", + "yyyyMMdd'T'hhmmss" +] + +macro genPropTypes( + props: static[openarray[ tuple[a: VC4_PropertyName, b: VC4_ValueType]]] + ): untyped = + + result = newNimNode(nnkTypeSection) + + for (pn, pt) in props: + var name: string = $pn + if name.len > 1: name = name[0] & name[1..^1].toLower + let typeName = ident("VC4_" & name) + + let parentType = + case pt + of vtDateTimeOrText: ident("VC4_DateTimeOrTextProperty") + of vtText: ident("VC4_TextProperty") + of vtTextList: ident("VC4_TextListProperty") + of vtTimestamp: ident("VC4_DateTimeProperty") + of vtTextOrUri: ident("VC4_TextOrUriProperty") + of vtUri: ident("VC4_UriProperty") + else: + raise newException(ValueError, + "types for " & $pn & " properties must be hand-written") + + result.add( + nnkTypeDef.newTree( + nnkPostfix.newTree(ident("*"), typeName), + newEmptyNode(), + nnkRefTy.newTree( + nnkObjectTy.newTree( + newEmptyNode(), + nnkOfInherit.newTree(parentType), + newEmptyNode())))) + + # echo result.treeRepr + +# General VCard 4 data types +type + PidValue* = object + sourceId*: int + propertyId*: int + + VC4_Property* = ref object of RootObj + propertyId: int + group*: Option[string] + params*: seq[VCParam] + + # TODO: write accessors + VC4_DateTimeOrTextProperty* = ref object of VC4_Property + valueType: VC4_ValueType # should only be vtDateAndOrTime or vtText + value*: string + year*: Option[int] + month*: Option[int] + day*: Option[int] + hour*: Option[int] + minute*: Option[int] + second*: Option[int] + timezone*: Option[string] + + VC4_TextListProperty* = ref object of VC4_Property + value*: seq[string] + + VC4_TextProperty* = ref object of VC4_Property + value*: string + + VC4_TextOrUriProperty* = ref object of VC4_Property + isUrl: bool + value*: string + + VC4_UriProperty* = ref object of VC4_Property + mediaType*: Option[string] + value*: string + + VC4_DateTimeProperty* = ref object of VC4_Property + value*: DateTime + + VC4_UnknownProperty* = ref object of VC4_Property + name*: string + value*: string + + VCard4* = ref object of VCard + nextPropertyId: int + content*: seq[VC4_Property] + pidParam*: seq[PidValue] + +# Hand-written implementations for more complicated property types +type + VC4_Type* = enum + ## Enum defining the well-known values for the TYPE parameter in general. + ## Because the specification actually allows any value, this is provided as + ## a convenience for accessing the standard values. + tWork = "work", + tHome = "home" + + VC4_TelType* = enum + ## Enum defining the well-known values for the TYPE parameter used by the + ## TEL property. Because the specification actually allows any value, this + ## is provided as a convenience for accessing the standard values. + ttWork = "work", + ttHome = "home", + ttText = "text", + ttVoice = "voice", + ttFax = "fax", + ttCell = "cell", + ttVideo = "video", + ttPager = "pager", + ttTextPhone = "textphone" + + VC4_RelatedType* = enum + ## Enum defining the well-known values for the TYPE parameter used by the + ## RELATED property. Because the specification actually allows any value, + ## this is provided as a convenience for accessing the standard values. + trContact = "contact", + trAcquaintance = "acquaintance", + trFriend = "friend", + trMet = "met", + trCoWorker = "co-worker", + trColleague = "colleague", + trCoResident = "co-resident", + trNeighbor = "neighbor", + trChild = "child", + trParent = "parent", + trSibling = "sibling", + trSpouse = "spouse", + trKin = "kin", + trMuse = "muse", + trCrush = "crush", + trDate = "date", + trSweetheart = "sweetheart", + trMe = "me", + trAgent = "agent", + trEmergency = "emergency" + + VC4_N* = ref object of VC4_Property + family*: seq[string] + given*: seq[string] + additional*: seq[string] + prefixes*: seq[string] + suffixes*: seq[string] + + VC4_Sex* = enum + Male = "M" + Female = "F" + Other = "O" + NoneNa = "N" + Unknown = "U" + + VC4_Gender* = ref object of VC4_Property + sex*: Option[VC4_Sex] + gender*: Option[string] + + VC4_Adr* = ref object of VC4_Property + poBox*: string + ext*: string + street*: string + locality*: string + region*: string + postalCode*: string + country*: string + + VC4_ClientPidMap* = ref object of VC4_Property + id*: int + uri*: string + + VC4_Rev* = ref object of VC4_Property + value*: DateTime + +# Generate all simple property types +genPropTypes(fixedValueTypeProperties) + +# Internal Utility/Implementation +# ============================================================================= + +template takePropertyId(vc4: VCard4): int = + vc4.nextPropertyId += 1 + vc4.nextPropertyId - 1 + +func flattenParameters( + params: seq[VCParam], + addtlParams: varargs[VCParam] = @[] + ): seq[VCParam] = + + let paramTable = newTable[string, seq[string]]() + let allParams: seq[VCParam] = + params & + addtlParams.toSeq --> filter(it.values.len > 0) + + for p in allParams: + let pname = p.name.toUpper + if paramTable.contains(pname): + for v in p.values: + if not paramTable[pname].contains(v): + paramTable[pname].add(v) + else: + let values = p.values + paramTable[pname] = values + + result = @[] + for k, v in paramTable.pairs: result.add((k, v)) + +proc parseDateAndOrTime[T]( + prop: var T, + value: string + ): void = + + var p = VCardParser(filename: value) + + try: + p.open(newStringStream(value)) + p.setBookmark + prop.year = none[int]() + prop.month = none[int]() + prop.day = none[int]() + prop.hour = none[int]() + prop.minute = none[int]() + prop.second = none[int]() + prop.timezone = none[string]() + + if p.peek != 'T': + # Attempt to parse the year + if p.peek == '-': p.expect("--") + else: prop.year = some(parseInt(p.read & p.read)) + + # Attempt to parse the month + if DIGIT.contains(p.peek) or p.peek == '-': + if p.peek == '-': p.expect("-") + else: prop.month = some(parseInt(p.read & p.read)) + + # Attempt to parse the month + if DIGIT.contains(p.peek): + prop.day = some(parseInt(p.read & p.read)) + + if p.peek == 'T': + # Attempt to parse the hour + if p.peek == '-': p.expect("-") + else: prop.hour = some(parseInt(p.read & p.read)) + + # Attempt to parse the minute + if DIGIT.contains(p.peek) or p.peek == '-': + if p.peek == '-': p.expect("-") + else: prop.minute = some(parseInt(p.read & p.read)) + + # Attempt to parse the second + if DIGIT.contains(p.peek): + prop.second = some(parseInt(p.read & p.read)) + + # Attempt to parse the timezone + if {'-', '+', 'Z'}.contains(p.peek): + try: + p.setBookmark + discard p.read + var i = 0 + while i < 4 and DIGITS.contains(p.peek): + discard p.read + i += 1 + prop.timezone = some(p.readSinceBookmark) + finally: p.unsetBookmark + + except ValueError, IOError, OSError: + p.error("unable to parse date-and-or-time value: " & p.readSinceBookmark) + finally: p.unsetBookmark + +template validateType(p: VCardParser, params: seq[VCParam], t: VC4_ValueType) = + p.validateRequiredParameters(params, [("VALUE", $t)]) + +# Initializers +# ============================================================================= + +func addConditionalParams(prop: VC4_PropertyName, funcDef: NimNode) = + + let formalParams = funcDef[3] + let paramsInit = + case funcDef[6][0].kind + + # Add parameter mapping to the returned object construction. + # Specifically this is: + # FuncDef + # [6] -> Funtion body StatementList + # [0] -> ReturnStmt + # [0] -> ObjConstr + # [1] -> `params` value + # [1] -> flattenParams call + of nnkReturnStmt: funcDef[6][0][0][1][1] + + # Add parameter mapping to the returned object construction. + # Specifically this is: + # FuncDef + # [6] -> Funtion body StatementList + # [0] -> Asgn + # [1] -> ObjConstr + # [1] -> params ExprColonExpr + # [1] -> flattenParams Call + of nnkAsgn: funcDef[6][0][1][1][1] + + else: + raise newException(ValueError, "cannot generate conditional params " & + "initialization code for this function shape:\n\r " & funcDef.treeRepr) + + if supportedParameters["LANGUAGE"].contains(prop): + # Add "language" as a function parameter + formalParams.add(newIdentDefs( + ident("language"), + newEmptyNode(), + quote do: none[string]())) + + paramsInit.add(quote do: + ("LANGUAGE", if language.isSome: @[language.get] else: @[])) + + if supportedParameters["PREF"].contains(prop): + # Add "pref" and "pids" as function parameters + formalParams.add(newIdentDefs( + ident("pref"), + newEmptyNode(), + quote do: none[int]())) + + paramsInit.add(quote do: + ("PREF", if pref.isSome: @[$pref.get] else: @[])) + + + if supportedParameters["PID"].contains(prop): + # Add "pids" as a function parameter + formalParams.add(newIdentDefs( + ident("pids"), + quote do: seq[PidValue], + quote do: @[])) + + # Add PID parameter mapping to the object construction. See the note on the + # LANGUAGE for details on how this hooks into the AST + paramsInit.add(quote do: ("PID", pids --> map($it))) + + + if supportedParameters["TYPE"].contains(prop): + # Add "type" as a function parameter + formalParams.add(newIdentDefs( + ident("types"), + quote do: seq[string], + quote do: @[])) + + # Add TYPE parameter mapping to the object construction. See the note on + # the LANGUAGE parameter for details on how this hooks into the AST + paramsInit.add(quote do: ("TYPE", types)) + +func namesForProp(prop: VC4_PropertyName): + tuple[enumName, funcName, typeName: NimNode] = + + var name: string = $prop + if name.len > 1: name = name[0] & name[1..^1].toLower + return (ident("pn" & name), ident("newVC4_" & name), ident("VC4_" & name)) + +macro genDateTimeOrTextPropInitializers( + properties: static[openarray[VC4_PropertyName]] + ): untyped = + + result = newStmtList() + for prop in properties: + let (enumName, funcName, typeName) = namesForProp(prop) + let datetimeFuncDef = genAstOpt({kDirtyTemplate}, enumName, funcName, typeName): + func funcName*( + value: DateTime, + altId: Option[string] = none[string](), + group: Option[string] = none[string](), + params: seq[VCParam] = @[]): typeName = + return typeName( + params: flattenParameters(params, + ("ALTID", if altId.isSome: @[altId.get] else: @[])), + group: group, + value: value.format(TIMESTAMP_FORMATS[0]), + year: some(value.year), + month: some(ord(value.month)), + day: some(ord(value.monthday)), + hour: some(ord(value.hour)), + minute: some(ord(value.minute)), + second: some(ord(value.second)), + timezone: some(value.format("ZZZ")), + valueType: vtDateAndOrTime) + + let textFuncDef = genAstOpt({kDirtyTemplate}, enumName, funcName, typeName): + proc funcName*( + value: string, + altId: Option[string] = none[string](), + group: Option[string] = none[string](), + params: seq[VCParam] = @[]): typeName = + result = typeName( + params: flattenParameters(params, + ("ALTID", if altId.isSome: @[altId.get] else: @[])), + group: group, + value: value, + valueType: vtText) + + result.parseDateAndOrTime(value) + + addConditionalParams(prop, datetimeFuncDef) + addConditionalParams(prop, textFuncDef) + result.add(textFuncDef) + result.add(datetimeFuncDef) + +macro genTextPropInitializers( + properties: static[openarray[VC4_PropertyName]] + ): untyped = + + result = newStmtList() + for prop in properties: + let (enumName, funcName, typeName) = namesForProp(prop) + let funcDef = genAstOpt({kDirtyTemplate}, enumName, funcName, typeName): + func funcName*( + value: string, + altId: Option[string] = none[string](), + group: Option[string] = none[string](), + params: seq[VCParam] = @[]): typeName = + return typeName( + params: flattenParameters(params, + ("ALTID", if altId.isSome: @[altId.get] else: @[])), + group: group, + value: value) + + addConditionalParams(prop, funcDef) + result.add(funcDef) + +macro genTextListPropInitializers( + properties: static[openarray[VC4_PropertyName]] + ): untyped = + + result = newStmtList() + + for prop in properties: + let (enumName, funcName, typeName) = namesForProp(prop) + let funcDef = genAstOpt({kDirtyTemplate}, enumName, funcName, typeName): + func funcName*( + value: seq[string], + altId: Option[string] = none[string](), + group: Option[string] = none[string](), + params: seq[VCParam] = @[]): typeName = + return typeName( + params: flattenParameters(params, + ("ALTID", if altId.isSome: @[altId.get] else: @[])), + group: group, + value: value) + + addConditionalParams(prop, funcDef) + result.add(funcDef) + +macro genTextOrUriPropInitializers( + properties: static[openarray[VC4_PropertyName]] + ): untyped = + + result = newStmtList() + for prop in properties: + let (enumName, funcName, typeName) = namesForProp(prop) + let funcDef = genAstOpt({kDirtyTemplate}, enumName, funcName, typeName): + func funcName*( + value: string, + isUrl = false, + altId: Option[string] = none[string](), + group: Option[string] = none[string](), + params: seq[VCParam] = @[]): typeName = + return typeName( + params: flattenParameters(params, + ("ALTID", if altId.isSome: @[altId.get] else: @[])), + isUrl: isUrl, + group: group) + + addConditionalParams(prop, funcDef) + result.add(funcDef) + +macro genUriPropInitializers( + properties: static[openarray[VC4_PropertyName]] + ): untyped = + + result = newStmtList() + for prop in properties: + let (enumName, funcName, typeName) = namesForProp(prop) + let funcDef = genAstOpt({kDirtyTemplate}, enumName, funcName, typeName): + func funcName*( + value: string, + altId: Option[string] = none[string](), + mediaType: Option[string] = none[string](), + group: Option[string] = none[string](), + params: seq[VCParam] = @[]): typeName = + return typeName( + params: flattenParameters(params, + ("ALTID", if altId.isSome: @[altId.get] else: @[])), + group: group, + mediaType: mediaType, + value: value) + + addConditionalParams(prop, funcDef) + result.add(funcDef) + +genDateTimeOrTextPropInitializers(fixedValueTypeProperties --> + filter(it[1] == vtDateTimeOrText).map(it[0])) + +genTextPropInitializers(fixedValueTypeProperties --> + filter(it[1] == vtText).map(it[0])) + +genTextListPropInitializers(fixedValueTypeProperties --> + filter(it[1] == vtTextList).map(it[0])) + +genTextOrUriPropInitializers(fixedValueTypeProperties --> + filter(it[1] == vtTextOrUri).map(it[0])) + +genUriPropInitializers(fixedValueTypeProperties --> + filter(it[1] == vtUri).map(it[0])) + +func newVC4_N*( + family: seq[string] = @[], + given: seq[string] = @[], + additional: seq[string] = @[], + prefixes: seq[string] = @[], + suffixes: seq[string] = @[], + altId: Option[string] = none[string](), + group: Option[string] = none[string](), + params: seq[VCParam] = @[]): VC4_N = + + return assignFields( + VC4_N(params: flattenParameters(params, + ("ALTID", if altId.isSome: @[altId.get] else: @[]))), + group, family, given, additional, prefixes, suffixes) + +func newVC4_Gender*( + sex: Option[VC4_Sex] = none[VC4_Sex](), + gender: Option[string] = none[string](), + altId: Option[string] = none[string](), + group: Option[string] = none[string](), + params: seq[VCParam] = @[]): VC4_Gender = + + return assignFields( + VC4_Gender(params: flattenParameters(params, + ("ALTID", if altId.isSome: @[altId.get] else: @[]))), + sex, gender, group) + +func newVC4_Adr*( + poBox = "", + ext = "", + street = "", + locality = "", + region = "", + postalCode = "", + country = "", + altId: Option[string] = none[string](), + geo: Option[string] = none[string](), + group: Option[string] = none[string](), + label: Option[string] = none[string](), + language: Option[string] = none[string](), + params: seq[VCParam] = @[], + pids: seq[PidValue] = @[], + pref: Option[int] = none[int](), + types: seq[string] = @[], + tz: Option[string] = none[string]()): VC4_Adr = + + if pref.isSome and (pref.get < 1 or pref.get > 100): + raise newException(ValueError, "PREF must be an integer between 1 and 100") + + return assignFields( + VC4_Adr(params: flattenParameters(params, + ("ALTID", if altId.isSome: @[altId.get] else: @[]), + ("GEO", if geo.isSome: @[geo.get] else: @[]), + ("LABEL", if label.isSome: @[label.get] else: @[]), + ("LANGUAGE", if language.isSome: @[language.get] else: @[]), + ("PID", pids --> map($it)), + ("PREF", if pref.isSome: @[$pref.get] else: @[]), + ("TYPE", types), + ("TZ", if tz.isSome: @[tz.get] else: @[]))), + poBox, ext, street, locality, region, postalCode, country, group) + +func newVC4_ClientPidMap*( + id: int, + uri: string, + group: Option[string] = none[string](), + params: seq[VCParam] = @[]): VC4_ClientPidMap = + + result = assignFields( + VC4_ClientPidMap(params: flattenParameters(params)), + id, uri, group) + +func newVC4_Rev*( + value: DateTime, + group: Option[string] = none[string](), + params: seq[VCParam]= @[]): VC4_Rev = + + return assignFields( + VC4_Rev(params: flattenParameters(params)), + value, group) + +# Accessors +# ============================================================================= + +macro genTypeAccessors(props: static[openarray[VC4_PropertyName]]): untyped = + + result = newStmtList() + + for p in props: + var name = $p + if name.len > 1: name = name[0] & name[1..^1].toLower + let typeName = ident("VC4_" & name) + + let typeFun = genAstOpt({kDirtyTemplate}, typeName): + func types*(prop: typeName): seq[string] = + let typeParam = prop.params --> find(it.name == "TYPE") + if typeParam.isSome: return typeParam.get.values + else: return @[] + result.add(typeFun) + +genTypeAccessors(supportedParameters["TYPE"].toSeq()) + +macro genNameAccessors(propNames: static[seq[VC4_PropertyName]]): untyped = + result = newStmtList() + + let genericFunc = genAstOpt({kDirtyTemplate}): + func name*(p: VC4_Property): string = + if p of VC4_UnknownProperty: + return cast[VC4_UnknownProperty](p).name + + let genericIfBlock = genericFunc[6][0] + result.add(genericFunc) + + block: + let funcDef = genAstOpt({kDirtyTemplate}): + func name*(p: VC4_UnknownProperty): string = p.name + + result.add(funcDef) + + let memSafePNs = propNames + let propNamesToProcess = (memSafePNs --> filter(it != pnUnknown)) + for pn in propNamesToProcess: + let (enumName, _, typeName) = namesForProp(pn) + + let genericCond = nnkElifExpr.newTree( + nnkInfix.newTree(ident("of"), ident("p"), typeName), + quote do: return $`enumName`) + + let funcDef = genAstOpt({kDirtyTemplate}, enumName, typeName): + func name*(p: typeName): string = $enumName + + result.add(funcDef) + genericIfBlock.add(genericCond) + + # echo result.repr + +genNameAccessors(toSeq(VC4_PropertyName)) + +# Setters +# ============================================================================= + +func set*[T: VC4_Property](vc4: VCard4, content: varargs[T]): void = + for c in content: + var nc = c + let existingIdx = vc4.content.indexOfIt(it of T) + if existingIdx < 0: + nc.propertyId = vc4.takePropertyId + vc4.content.add(nc) + else: + nc.propertyId = vc4.content[existingIdx].propertyId + vc4.content[existingIdx] = nc + +func add*[T: VC4_Property](vc4: VCard4, content: varargs[T]): void = + for c in content: + var nc = c + nc.propertyId = vc4.takePropertyId + vc4.content.add(nc) + +func updateOrAdd*[T: VC4_Property](vc4: VCard4, content: seq[T]): VCard4 = + for c in content: + let existingIdx = vc4.content.indexOfIt(it.propertyId == c.propertyId) + if existingIdx < 0: vc4.content.add(c) + else: c.content[existingIdx] = c + +# Ouptut +# ============================================================================= +#func serialize(p: VC4_Property): string = +# if c of + +func `$`*(pid: PidValue): string = $pid.propertyId & "." & $pid.sourceId + +#[ +func `$`*(vc4: VCard4): string = + result = "BEGIN:VCARD" & CRLF + result &= "VERSION:4.0" & CRLF + for p in (vc4.content --> filter(not (it of VC4_Version))): + result &= foldContentLine(serialize(p)) & CRLF + result &= "END:VCARD" & CRLF +]# + + +# Parsing +# ============================================================================= + +const TEXT_CHARS = WSP + NON_ASCII + { '\x21'..'\x2B', '\x2D'..'\x7E' } +const QSAFE_CHARS = WSP + { '\x21', '\x23'..'\x7E' } + NON_ASCII +const COMPONENT_CHARS = WSP + NON_ASCII + + { '\x21'..'\x2B', '\x2D'..'\x3A', '\x3C'..'\x7E' } + +func parsePidValues(param: VCParam): seq[PidValue] + {.raises:[VCardParsingError].} = + + result = @[] + for v in param.values: + try: + let pieces = v.split(".") + if pieces.len != 2: raise newException(ValueError, "") + result.add(PidValue( + propertyId: parseInt(pieces[0]), + sourceId: parseInt(pieces[1]))) + except ValueError: + raise newException(VCardParsingError, "PID value expected to be two " & + "integers separated by '.' (2.1 for example)") + +proc parseTimestamp(value: string): DateTime = + for fmt in TIMESTAMP_FORMATS: + try: return value.parse(fmt) + except: discard + raise newException(VCardParsingError, "unable to parse timestamp value: " & value) + +proc readParamValue(p: var VCardParser): string = + ## Read a single parameter value at the current read position or error. Note + ## that this implementation differs from RFC 6450 in two important ways: + ## 1. It implements the escaping logic defined in RFC 6868 to allow newlines, + ## and double-quote characters to be represented in parameter values. + ## 2. It ALWAYS treats ',' as value delimiters when outside quoted values + ## and NEVER treats them as delimiter within quoted values. This has been + ## mentioned in several errata filed for RCF 6350, but no updated document + ## has been released since. A decision is required in order to make the + ## parsing logic unambigous. + + result = newStringOfCap(32) + let quoted = p.peek == '"' + if quoted: discard p.read + + while (quoted and QSAFE_CHARS.contains(p.peek)) or + (not quoted and SAFE_CHARS.contains(p.peek)): + + let c = p.read + if c == '^': + case p.peek + of '^': result.add(p.read) + of 'n', 'N': + result.add('\n') + discard p.read + of '\'': + result.add('"') + discard p.read + else: + p.error("invalid character escape: '^$1'" % [$p.read]) + else: result.add(c) + + if quoted and p.read != '"': + p.error("quoted parameter value expected to end with a " & + "double quote (\")") + + if result.len == 0: + p.error("expected to read a parameter value") + +proc readParams(p: var VCardParser): seq[VCParam] = + result = @[] + while p.peek == ';': + discard p.read + var param: VCParam = (p.readName, @[]) + p.expect("=", true) + param.values.add(p.readParamValue) + while p.peek == ',': + discard p.read + param.values.add(p.readParamValue) + result.add(param) + +proc readComponentValue( + p: var VCardParser, + ignorePrefix: set[char] = {}, + requiredPrefix = none[char]()): string = + ## Read a component value (defined by RFC6350) from the current read + ## position. This is very similar to readTextValue. The difference is that + ## component values cannot contain unescaped semicolons + result = newStringOfCap(32) + + if requiredPrefix.isSome: + if p.peek != requiredPrefix.get: + p.error("expected to read '" & $requiredPrefix.get & "' but found '" & + $p.read & "'") + discard p.read + + if ignorePrefix.contains(p.peek): discard p.read + while COMPONENT_CHARS.contains(p.peek): + let c = p.read + + if c == '\\': + case p.peek + of '\\', ',', ';': result.add(p.read) + of 'n', 'N': + result.add('\n') + discard p.read + else: + p.error("invalid character escape: '\\$1'" % [$p.read]) + else: result.add(c) + +proc readComponentValueList( + p: var VCardParser, + seps: set[char] = {','}, + requiredPrefix = none[char]() + ): seq[string] = + ## Read in a list of multiple component values (defined by RFC2426) from the + ## current read position. This is used, for example, for the N and ADR + ## properties. + + if requiredPrefix.isSome: + if p.peek != requiredPrefix.get: + p.error("expected to read '" & $requiredPrefix.get & "' but found '" & + $p.read & "'") + discard p.read + + result = @[p.readComponentValue] + while seps.contains(p.peek): result.add(p.readComponentValue(ignorePrefix = seps)) + +proc readTextValue(p: var VCardParser, ignorePrefix: set[char] = {}): string = + ## Read a text-value (defined by RFC6350) from the current read position. + result = newStringOfCap(32) + + if ignorePrefix.contains(p.peek): discard p.read + while TEXT_CHARS.contains(p.peek): + let c = p.read + + if c == '\\': + case p.peek + of '\\', ',': result.add(p.read) + of 'n', 'N': + result.add('\n') + discard p.read + else: + p.error("invalid character escape: '\\$1'" % [$p.read]) + else: result.add(c) + +proc readTextValueList( + p: var VCardParser, + seps: set[char] = {','}, + requiredPrefix = none[char]() + ): seq[string] = + ## Read in a list of multiple text-value (defined by RFC2426) values from the + ## current read position. This is used, for example, for the N and ADR + ## properties. + + if requiredPrefix.isSome: + if p.peek != requiredPrefix.get: + p.error("expected to read '" & $requiredPrefix.get & "' but found '" & + $p.read & "'") + discard p.read + + result = @[p.readTextValue] + while seps.contains(p.peek): result.add(p.readTextValue(ignorePrefix = seps)) + +macro genPropParsers( + genProps: static[openarray[tuple[a: VC4_PropertyName, b: VC4_ValueType]]], + group: Option[string], + name: string, + params: seq[VCParam], + contents: var seq[VC4_Property], + p: var VCardParser + ): untyped = + + macro ac(value: untyped): untyped = + # Assign Common parameter values found on all properties + result = value + result.add(newTree(nnkExprColonExpr, ident("group"), ident("group"))) + result.add(newTree(nnkExprColonExpr, ident("params"), ident("params"))) + # echo result.treeRepr + + result = nnkCaseStmt.newTree(quote do: + parseEnum[VC4_PropertyName](name, pnUnknown)) + + for (pn, pt) in genProps: + let (enumName, initFuncName, typeName) = namesForProp(pn) + + let parseCase = nnkOfBranch.newTree(quote do: `enumName`, newEmptyNode()) + result.add(parseCase) + + case pt + of vtDateTimeOrText: + parseCase[1] = genAst(contents, initFuncName, typeName, p): + let valueType = params.getSingleValue("TYPE") + if valueType.isSome and valueType.get != $vtDateAndOrTime and + valueType.get != $vtText: + p.error("VALUE must be either \"date-and-or-time\" or \"text\" for " & + name & " properties.") + + contents.add(initFuncName( + value = p.readValue, + group = group, + params = params)) + + of vtText: + parseCase[1] = genAst(contents, typeName): + p.validateType(params, pt) + contents.add(ac(typeName(value: p.readTextValue))) + + of vtTextList: + parseCase[1] = genAst(contents, typeName): + p.validateType(params, vtText) + contents.add(ac(typeName(value: p.readTextValueList))) + + of vtTextOrUri: + parseCase[1] = genAst(contents, typeName): + let valueType = params.getSingleValue("TYPE") + if valueType.isNone or valueType.get == $vtUri: + contents.add(ac(typeName(value: p.readValue))) + elif valueType.isSome and valueType.get == $vtText: + contents.add(ac(typeName(value: p.readTextValue))) + else: + p.error("VALUE must be either \"text\" or \"uri\" for " & name & + " properties.") + + of vtUri: + parseCase[1] = genAst(typeName, contents): + p.validateType(params, pt) + contents.add(ac(typeName(value: p.readValue))) + + else: + raise newException(ValueError, "parse statements for for " & $pn & + " properties must be hand-written") + + block: # N + let parseCase = nnkOfBranch.newTree(ident("pnN"), newEmptyNode()) + result.add(parseCase) + parseCase[1] = genAst(contents): + p.validateType(params, vtText) + contents.add(ac(VC4_N( + family: p.readComponentValueList, + given: p.readComponentValueList(requiredPrefix = some(';')), + additional: p.readComponentValueList(requiredPrefix = some(';')), + prefixes: p.readComponentValueList(requiredPrefix = some(';')), + suffixes: p.readComponentValueList(requiredPrefix = some(';'))))) + + + block: # GENDER + let parseCase = nnkOfBranch.newTree(ident("pnGender"), newEmptyNode()) + result.add(parseCase) + parseCase[1] = genAst(contents): + p.validateType(params, vtText) + var sex: Option[VC4_Sex] = none[VC4_Sex]() + let sexCh = p.read + if {'M', 'F', 'O', 'N', 'U'}.contains(sexCh): + sex = some(parseEnum[VC4_Sex]($sexCh)) + elif sexCh != ';': + p.error("The sex component of the GENDER property must be one of " & + "M, F, O, N, or U (it was " & $sexCh & ")") + + contents.add(ac(VC4_Gender( + sex: sex, + gender: + if sexCh == ';' or sex.isSome: some(p.readTextValue) + else: none[string]()))) + + + block: # ADR + let parseCase = nnkOfBranch.newTree(ident("pnAdr"), newEmptyNode()) + result.add(parseCase) + parseCase[1] = genAst(contents): + p.validateType(params, vtText) + contents.add(ac(VC4_Adr( + poBox: p.readComponentValue, + ext: p.readComponentValue(requiredPrefix = some(';')), + street: p.readComponentValue(requiredPrefix = some(';')), + locality: p.readComponentValue(requiredPrefix = some(';')), + region: p.readComponentValue(requiredPrefix = some(';')), + postalCode: p.readComponentValue(requiredPrefix = some(';')), + country: p.readComponentValue(requiredPrefix = some(';'))))) + + block: # REV + let parseCase = nnkOfBranch.newTree(ident("pnRev"), newEmptyNode()) + result.add(parseCase) + parseCase[1] = genAst(contents): + p.validateType(params, vtTimestamp) + contents.add(ac(VC4_Rev(value: parseTimestamp(p.readValue)))) + + block: # CLIENTPIDMAP + let parseCase = nnkOfBranch.newTree(ident("pnClientPidMap"), newEmptyNode()) + result.add(parseCase) + parseCase[1] = genAst(contents): + contents.add(ac(VC4_ClientPidMap( + id: parseInt(p.readComponentValue), + uri: p.readTextValue(ignorePrefix = {';'})))) + + block: # UNKNOWN + let parseCase = nnkOfBranch.newTree(ident("pnUnknown"), newEmptyNode()) + result.add(parseCase) + parseCase[1] = genAst(contents): + contents.add(ac(VC4_UnknownProperty(name: name, value: p.readValue))) + # echo result.repr + +proc parseContentLines*(p: var VCardParser): seq[VC4_Property] = + result = @[] + + while true: + let group = p.readGroup + let name = p.readName + if name == "END": + p.expect(":VCARD" & CRLF) + break + let params = p.readParams + p.expect(":") + + genPropParsers(fixedValueTypeProperties, group, name, params, result, p) + + #[ + of $pnNickname: + of $pnPhoto: + of $pnBday: + of $pnAnniversary: + of $pnGender: + of $pnAdr: + of $pnTel: + of $pnEmail: + of $pnImpp: + of $pnLang: + of $pnTz: + of $pnGeo: + of $pnTitle: + of $pnRole: + of $pnLogo: + of $pnOrg: + of $pnMember: + of $pnRelated: + of $pnCategories: + of $pnNote: + of $pnProdId: + of $pnRev: + of $pnSound: + of $pnUid: + of $pnClientPidMap: + of $pnUrl: + of $pnVersion: + of $pnKey: + of $pnFbUrl: + of $pnCaladrUri: + of $pnCalUri: + ]# + #else: discard + + +# Private Function Unit Tests +# ============================================================================ +proc runVCard4PrivateTests*() = + + proc initParser(input: string): VCardParser = + result = VCardParser(filename: "private unittests") + lexer.open(result, newStringStream(input)) + + # "readGroup": + block: + var p = initParser("mygroup.BEGIN:VCARD") + let g = p.readGroup + assert g.isSome + assert g.get == "mygroup" + + # "all property types defined" + block: + assert declared(VC4_Source) + assert declared(VC4_Kind) + assert declared(VC4_Xml) + assert declared(VC4_Fn) + assert declared(VC4_N) + assert declared(VC4_Nickname) + assert declared(VC4_Photo) + assert declared(VC4_Bday) + assert declared(VC4_Anniversary) + assert declared(VC4_Gender) + assert declared(VC4_Adr) + assert declared(VC4_Tel) + assert declared(VC4_Email) + assert declared(VC4_Impp) + assert declared(VC4_Lang) + assert declared(VC4_Tz) + assert declared(VC4_Geo) + assert declared(VC4_Title) + assert declared(VC4_Role) + assert declared(VC4_Logo) + assert declared(VC4_Org) + assert declared(VC4_Member) + assert declared(VC4_Related) + assert declared(VC4_Categories) + assert declared(VC4_Note) + assert declared(VC4_Prodid) + assert declared(VC4_Rev) + assert declared(VC4_Sound) + assert declared(VC4_Uid) + assert declared(VC4_Clientpidmap) + assert declared(VC4_Url) + assert declared(VC4_Version) + assert declared(VC4_Key) + assert declared(VC4_Fburl) + assert declared(VC4_Caladruri) + assert declared(VC4_Caluri) + + # "all property initializers defined" + block: + assert declared(new_VC4_Source) + assert declared(new_VC4_Kind) + assert declared(new_VC4_Xml) + assert declared(new_VC4_Fn) + assert declared(new_VC4_N) + assert declared(new_VC4_Nickname) + assert declared(new_VC4_Photo) + assert declared(new_VC4_Bday) + assert declared(new_VC4_Anniversary) + assert declared(new_VC4_Gender) + assert declared(new_VC4_Adr) + assert declared(new_VC4_Tel) + assert declared(new_VC4_Email) + assert declared(new_VC4_Impp) + assert declared(new_VC4_Lang) + assert declared(new_VC4_Tz) + assert declared(new_VC4_Geo) + assert declared(new_VC4_Title) + assert declared(new_VC4_Role) + assert declared(new_VC4_Logo) + assert declared(new_VC4_Org) + assert declared(new_VC4_Member) + assert declared(new_VC4_Related) + assert declared(new_VC4_Categories) + assert declared(new_VC4_Note) + assert declared(new_VC4_Prodid) + assert declared(new_VC4_Rev) + assert declared(new_VC4_Sound) + assert declared(new_VC4_Uid) + assert declared(new_VC4_Clientpidmap) + assert declared(new_VC4_Url) + assert declared(new_VC4_Version) + assert declared(new_VC4_Key) + assert declared(new_VC4_Fburl) + assert declared(new_VC4_Caladruri) + assert declared(new_VC4_Caluri) diff --git a/tests/tvcard4.nim b/tests/tvcard4.nim new file mode 100644 index 0000000..1a4093c --- /dev/null +++ b/tests/tvcard4.nim @@ -0,0 +1,9 @@ +import options, unittest, zero_functional + +import ./vcard +import ./vcard/vcard4 + +suite "vcard/vcard4": + + test "vcard4/private tests": + runVcard4PrivateTests()