Proto3.Suite.DotProto.Internal

This module provides misc internal helpers and utilities

Utilities

foldMapM :: (Foldable t, Monad m, Monoid b, Semigroup b) => (a -> m b) -> t a -> m b

Like foldMap, but with an effectful projection.

type GettingM r s a = forall m. Applicative m => (a -> Compose m (Const r) a) -> s -> Compose m (Const r) s

Like Getting, but allows for retrieving the r element in some Applicative context m.

foldMapOfM :: (Applicative m, Monoid r) => GettingM r s a -> (a -> m r) -> s -> m r

Given an effectful projection from a into a monoid r, retrieve the sum of all a values in an s structure as targetted by the GettingM optic. Note that the Monoid constraint on r is implicit via Const, but we note it in the type for clarity.

mapKeysM :: (Monad m, Ord k2) => (k1 -> m k2) -> Map k1 a -> m (Map k2 a)

>>> :set -XOverloadedStrings

dieLines :: MonadIO m => Text -> m a

Reading files

toModulePath :: FilePath -> Either String Path

toModulePath takes an include-relative path to a .proto file and produces a "module path" which is used during code generation.

Note that, with the exception of the '.proto' portion of the input filepath, this function interprets . in the filename components as if they were additional slashes (assuming that the . is not the first character, which is merely ignored). So e.g. "googleprotobuftimestamp.proto" and "google.protobuf.timestamp.proto" map to the same module path.

>>> toModulePath "/absolute/path/fails.proto"
Left "expected include-relative path"

>>> toModulePath "relative/path/to/file_without_proto_suffix_fails"
Left "expected .proto suffix"

>>> toModulePath "relative/path/to/file_without_proto_suffix_fails.txt"
Left "expected .proto suffix"

>>> toModulePath "../foo.proto"
Left "expected include-relative path, but the path started with ../"

>>> toModulePath "foo..proto"
Left "path contained unexpected .. after canonicalization, please use form x.y.z.proto"

>>> toModulePath "foo/bar/baz..proto"
Left "path contained unexpected .. after canonicalization, please use form x.y.z.proto"

>>> toModulePath "foo.bar../baz.proto"
Left "path contained unexpected .. after canonicalization, please use form x.y.z.proto"

>>> toModulePath "google/protobuf/timestamp.proto"
Right (Path {components = "Google" :| ["Protobuf","Timestamp"]})

>>> toModulePath "a/b/c/google.protobuf.timestamp.proto"
Right (Path {components = "A" :| ["B","C","Google","Protobuf","Timestamp"]})

>>> toModulePath "foo/FiLeName_underscore.and.then.some.dots.proto"
Right (Path {components = "Foo" :| ["FiLeName_underscore","And","Then","Some","Dots"]})

importProto :: (MonadIO m, MonadError CompileError m) => [FilePath] -> FilePath -> FilePath -> m DotProto

importProto searchPaths toplevel inc attempts to import include-relative inc after locating it somewhere in the searchPaths; toplevel is simply the path of toplevel .proto being processed so we can report it in an error message. This function terminates the program if it cannot find the file to import or if it cannot construct a valid module path from it.

type FindProtoResult = Either String (Maybe (Path, FilePath))

findProto :: MonadIO m => [FilePath] -> FilePath -> m FindProtoResult

Attempts to locate the first (if any) filename that exists on the given search paths, and constructs the "module path" from the given include-relative filename (2nd parameter). Terminates the program with an error if the given pathname is not relative.

Pretty Error Messages

badModulePathErrorMsg :: FilePath -> String -> Text

importNotFoundErrorMsg :: [FilePath] -> FilePath -> FilePath -> Text

toplevelNotFoundErrorMsg :: [FilePath] -> FilePath -> Text

absolutePathErrorMsg :: Text

Type context

type TypeContext = Map DotProtoIdentifier DotProtoTypeInfo

A mapping from .proto type identifiers to their type information

data DotProtoTypeInfo

Information about messages and enumerations

Constructors

DotProtoTypeInfo

Fields

• dotProtoTypeInfoPackage :: DotProtoPackageSpec

  The package this type is defined in

• dotProtoTypeInfoParent :: DotProtoIdentifier

  The message this type is nested under, or Anonymous if it's top-level

• dotProtoTypeChildContext :: TypeContext

  The context that should be used for declarations within the scope of this type

• dotProtoTypeInfoKind :: DotProtoKind

  Whether this type is an enumeration or message

• dotProtoTypeInfoModulePath :: Path

  The include-relative module path used when importing this module

Instances

Show DotProtoTypeInfo

Defined in Proto3.Suite.DotProto.Internal

Methods

showsPrec :: Int -> DotProtoTypeInfo -> ShowS

show :: DotProtoTypeInfo -> String

showList :: [DotProtoTypeInfo] -> ShowS

tiParent :: Lens' DotProtoTypeInfo DotProtoIdentifier

data DotProtoKind

Whether a definition is an enumeration or a message

Constructors

DotProtoKindEnum

DotProtoKindMessage

Instances

Bounded DotProtoKind

Defined in Proto3.Suite.DotProto.Internal

Methods

minBound :: DotProtoKind

maxBound :: DotProtoKind

Enum DotProtoKind

Defined in Proto3.Suite.DotProto.Internal

Methods

succ :: DotProtoKind -> DotProtoKind

pred :: DotProtoKind -> DotProtoKind

toEnum :: Int -> DotProtoKind

fromEnum :: DotProtoKind -> Int

enumFrom :: DotProtoKind -> [DotProtoKind]

enumFromThen :: DotProtoKind -> DotProtoKind -> [DotProtoKind]

enumFromTo :: DotProtoKind -> DotProtoKind -> [DotProtoKind]

enumFromThenTo :: DotProtoKind -> DotProtoKind -> DotProtoKind -> [DotProtoKind]

Eq DotProtoKind

Defined in Proto3.Suite.DotProto.Internal

Methods

(==) :: DotProtoKind -> DotProtoKind -> Bool

(/=) :: DotProtoKind -> DotProtoKind -> Bool

Ord DotProtoKind

Defined in Proto3.Suite.DotProto.Internal

Methods

compare :: DotProtoKind -> DotProtoKind -> Ordering

(<) :: DotProtoKind -> DotProtoKind -> Bool

(<=) :: DotProtoKind -> DotProtoKind -> Bool

(>) :: DotProtoKind -> DotProtoKind -> Bool

(>=) :: DotProtoKind -> DotProtoKind -> Bool

max :: DotProtoKind -> DotProtoKind -> DotProtoKind

min :: DotProtoKind -> DotProtoKind -> DotProtoKind

Show DotProtoKind

Defined in Proto3.Suite.DotProto.Internal

Methods

showsPrec :: Int -> DotProtoKind -> ShowS

show :: DotProtoKind -> String

showList :: [DotProtoKind] -> ShowS

Generating type contexts from ASTs

dotProtoTypeContext :: MonadError CompileError m => DotProto -> m TypeContext

definitionTypeContext :: MonadError CompileError m => Path -> DotProtoDefinition -> m TypeContext

isMessage :: TypeContext -> DotProtoIdentifier -> Bool

boolOption :: String -> [DotProtoOption] -> Maybe Bool

isPacked :: [DotProtoOption] -> Bool

isUnpacked :: [DotProtoOption] -> Bool

isPackable :: TypeContext -> DotProtoPrimType -> Bool

Returns True if the given primitive type is packable. The TypeContext is used to distinguish Named enums and messages, only the former of which are packable.

isMap :: DotProtoType -> Bool

Name resolution

concatDotProtoIdentifier :: MonadError CompileError m => DotProtoIdentifier -> DotProtoIdentifier -> m DotProtoIdentifier

toPascalCase :: String -> String

toPascalCase xs' sends a snake-case string xs to a pascal-cased string. Trailing underscores are not dropped from the input string and exactly double underscores are replaced by a single underscore.

toCamelCase :: String -> String

toCamelCase xs sends a snake-case string xs to a camel-cased string.

toUpperFirst :: String -> String

Uppercases the first character of a string.

Examples

>>> toUpperFirst "abc"
"Abc"

>>> toUpperFirst ""
""

segmentBy :: (a -> Bool) -> [a] -> [Either [a] [a]]

segmentBy p xs partitions xs into segments of Either [a] [a] with:

• Right sublists containing elements satisfying p, otherwise;
• Left sublists containing elements that do not satisfy p

Examples

>>> segmentBy (\c -> c == '_') "abc_123_xyz"
[Left "abc",Right "_",Left "123",Right "_",Left "xyz"]

suffixBy :: forall a. (a -> Bool) -> [a] -> Either [a] ([a], [a])

suffixBy p xs yields Right (xs', suf) if suf is the longest suffix satisfying p and xs' is the rest of the rest, otherwise the string is given back as Left xs signifying xs had no suffix satisfying p.

typeLikeName :: MonadError CompileError m => String -> m String

typeLikeName xs produces either the pascal-cased version of the string xs if it begins with an alphabetical character or underscore - which is replaced with X. A CompileError is emitted if the starting character is non-alphabetic or if xs == "".

fieldLikeName :: String -> String

fieldLikeName field is the casing transformation used to produce record selectors from message fields. If field is prefixed by a span of uppercase characters then that prefix will be lowercased while the remaining string is left unchanged.

prefixedEnumFieldName :: String -> String -> String

prefixedConName :: MonadError CompileError m => String -> String -> m String

prefixedMethodName :: MonadError CompileError m => String -> String -> m String

prefixedMethodName service method produces a Haskell record selector name for the service method method by joining the names service, method under concatenation on a camel-casing transformation.

prefixedFieldName :: MonadError CompileError m => String -> String -> m String

prefixedFieldName prefix field constructs a Haskell record selector name by prepending prefix in camel-case to the message field/service method name field.

dpIdentUnqualName :: MonadError CompileError m => DotProtoIdentifier -> m String

dpIdentQualName :: MonadError CompileError m => DotProtoIdentifier -> m String

nestedTypeName :: MonadError CompileError m => DotProtoIdentifier -> String -> m String

Given a DotProtoIdentifier for the parent type and the unqualified name of this type, generate the corresponding Haskell name

qualifiedMessageName :: MonadError CompileError m => DotProtoIdentifier -> DotProtoIdentifier -> m String

qualifiedMessageTypeName :: MonadError CompileError m => TypeContext -> DotProtoIdentifier -> DotProtoIdentifier -> m String

Codegen bookkeeping helpers

data QualifiedField

Bookeeping for qualified fields

Constructors

QualifiedField

Fields

• recordFieldName :: FieldName
• fieldInfo :: FieldInfo

Instances

Show QualifiedField

Defined in Proto3.Suite.DotProto.Internal

Methods

showsPrec :: Int -> QualifiedField -> ShowS

show :: QualifiedField -> String

showList :: [QualifiedField] -> ShowS

data FieldInfo

Bookkeeping for fields

Constructors

FieldOneOf OneofField

FieldNormal FieldName FieldNumber DotProtoType [DotProtoOption]

Instances

Show FieldInfo

Defined in Proto3.Suite.DotProto.Internal

Methods

showsPrec :: Int -> FieldInfo -> ShowS

show :: FieldInfo -> String

showList :: [FieldInfo] -> ShowS

data OneofField

Bookkeeping for oneof fields

Constructors

OneofField

Fields

• oneofType :: String
• subfields :: [OneofSubfield]

Instances

Show OneofField

Defined in Proto3.Suite.DotProto.Internal

Methods

showsPrec :: Int -> OneofField -> ShowS

show :: OneofField -> String

showList :: [OneofField] -> ShowS

data OneofSubfield

Bookkeeping for oneof subfields

Constructors

OneofSubfield

Fields

• subfieldNumber :: FieldNumber
• subfieldConsName :: String
• subfieldName :: FieldName
• subfieldType :: DotProtoType
• subfieldOptions :: [DotProtoOption]

Instances

Show OneofSubfield

Defined in Proto3.Suite.DotProto.Internal

Methods

showsPrec :: Int -> OneofSubfield -> ShowS

show :: OneofSubfield -> String

showList :: [OneofSubfield] -> ShowS

getQualifiedFields :: MonadError CompileError m => String -> [DotProtoMessagePart] -> m [QualifiedField]

foldQF

Arguments

:: (FieldName -> FieldNumber -> a)

projection for normal fields

-> (OneofField -> a)

projection for oneof fields

-> QualifiedField

-> a

Project qualified fields, given a projection function per field type.

fieldBinder :: FieldNumber -> String

oneofSubBinder :: OneofSubfield -> String

oneofSubDisjunctBinder :: [OneofSubfield] -> String

Errors

data CompileError

Constructors

CircularImport FilePath

CompileParseError ParseError

InternalError String

InvalidPackageName DotProtoIdentifier

InvalidMethodName DotProtoIdentifier

InvalidModuleName String

InvalidTypeName String

InvalidMapKeyType String

NoPackageDeclaration

NoSuchType DotProtoIdentifier

NonzeroFirstEnumeration String DotProtoIdentifier Int32

EmptyEnumeration String

Unimplemented String

Instances

Eq CompileError

Defined in Proto3.Suite.DotProto.Internal

Methods

(==) :: CompileError -> CompileError -> Bool

(/=) :: CompileError -> CompileError -> Bool

Show CompileError

Defined in Proto3.Suite.DotProto.Internal

Methods

showsPrec :: Int -> CompileError -> ShowS

show :: CompileError -> String

showList :: [CompileError] -> ShowS

internalError :: MonadError CompileError m => String -> m a

invalidTypeNameError :: MonadError CompileError m => String -> m a

_unimplementedError :: MonadError CompileError m => String -> m a

invalidMethodNameError :: MonadError CompileError m => DotProtoIdentifier -> m a

noSuchTypeError :: MonadError CompileError m => DotProtoIdentifier -> m a

protoPackageName :: MonadError CompileError m => DotProtoPackageSpec -> m DotProtoIdentifier