@enjoys/context-engine 1.1.0 → 1.1.2

package/data/implementation/objective-c.json

@@ -0,0 +1,48 @@
+{
+  "language": "objective-c",
+  "implementationPatterns": [
+    {
+      "interface": "Implementation",
+      "implementationKeyword": "@implementation",
+      "pattern": "@implementation\\s+(\\w+)",
+      "description": "Class implementation block"
+    },
+    {
+      "interface": "InterfaceDecl",
+      "implementationKeyword": "@interface",
+      "pattern": "@interface\\s+(\\w+)\\s*(?::\\s*(\\w+))?",
+      "description": "Class interface (header) declaration"
+    },
+    {
+      "interface": "ProtocolDecl",
+      "implementationKeyword": "@protocol",
+      "pattern": "@protocol\\s+(\\w+)",
+      "description": "Protocol declaration"
+    },
+    {
+      "interface": "ProtocolConformance",
+      "implementationKeyword": "<protocol>",
+      "pattern": "@interface\\s+(\\w+)\\s*\\([^)]*\\)\\s*<([\\w,\\s]+)>",
+      "description": "Category conforming to protocol(s)"
+    },
+    {
+      "interface": "Category",
+      "implementationKeyword": "()",
+      "pattern": "@implementation\\s+(\\w+)\\s*\\((\\w*)\\)",
+      "description": "Category implementation"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "@interface",
+      "@protocol",
+      "@required",
+      "@optional"
+    ],
+    "implementation": [
+      "@implementation",
+      "@synthesize",
+      "@dynamic"
+    ]
+  }
+}

package/data/implementation/pascal.json

@@ -0,0 +1,47 @@
+{
+  "language": "pascal",
+  "implementationPatterns": [
+    {
+      "interface": "ClassInherit",
+      "implementationKeyword": "class",
+      "pattern": "(\\w+)\\s*=\\s*class\\s*\\((\\w+)\\)",
+      "description": "Class inheriting from base class"
+    },
+    {
+      "interface": "InterfaceImpl",
+      "implementationKeyword": "class",
+      "pattern": "(\\w+)\\s*=\\s*class\\s*\\(.*,\\s*(I\\w+)",
+      "description": "Class implementing interface(s)"
+    },
+    {
+      "interface": "InterfaceDecl",
+      "implementationKeyword": "interface",
+      "pattern": "(\\w+)\\s*=\\s*interface",
+      "description": "Interface declaration"
+    },
+    {
+      "interface": "ImplSection",
+      "implementationKeyword": "implementation",
+      "pattern": "^implementation$",
+      "description": "Implementation section of unit"
+    },
+    {
+      "interface": "MethodImpl",
+      "implementationKeyword": "procedure/function",
+      "pattern": "(?:procedure|function)\\s+(\\w+)\\.(\\w+)",
+      "description": "Method implementation (ClassName.MethodName)"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "interface",
+      "class (abstract)",
+      "= interface"
+    ],
+    "implementation": [
+      "implementation",
+      "class(TBase)",
+      "procedure T.Method"
+    ]
+  }
+}

package/data/implementation/pascaligo.json

@@ -0,0 +1,40 @@
+{
+  "language": "pascaligo",
+  "implementationPatterns": [
+    {
+      "interface": "TypeDecl",
+      "implementationKeyword": "type",
+      "pattern": "type\\s+(\\w+)\\s+is",
+      "description": "Type definition"
+    },
+    {
+      "interface": "FunctionDecl",
+      "implementationKeyword": "function",
+      "pattern": "function\\s+(\\w+)\\s*\\(",
+      "description": "Function implementation"
+    },
+    {
+      "interface": "Entrypoint",
+      "implementationKeyword": "function",
+      "pattern": "function\\s+(main|\\w+)\\s*\\(.*action",
+      "description": "Contract entrypoint"
+    },
+    {
+      "interface": "ConstDecl",
+      "implementationKeyword": "const",
+      "pattern": "const\\s+(\\w+)\\s*:",
+      "description": "Constant definition"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "type",
+      "function signature"
+    ],
+    "implementation": [
+      "function...is",
+      "type...is",
+      "const"
+    ]
+  }
+}

package/data/implementation/perl.json

@@ -1,7 +1,58 @@
 {
   "language": "perl",
-  "implementationPatterns": [],
+  "implementationPatterns": [
+    {
+      "interface": "Package",
+      "implementationKeyword": "package",
+      "pattern": "package\\s+([\\w:]+)",
+      "description": "Package/class declaration"
+    },
+    {
+      "interface": "ISA",
+      "implementationKeyword": "@ISA",
+      "pattern": "@ISA\\s*=\\s*(?:qw)?[\\s(]*([\\w:]+)",
+      "description": "Inheritance via @ISA"
+    },
+    {
+      "interface": "UseBase",
+      "implementationKeyword": "use base",
+      "pattern": "use\\s+(?:base|parent)\\s+(?:qw)?[\\s('\"]*([\\w:]+)",
+      "description": "Inheritance via use base/parent"
+    },
+    {
+      "interface": "MooseRole",
+      "implementationKeyword": "with",
+      "pattern": "with\\s+['\"]([\\w:]+)['\"]",
+      "description": "Moose/Moo role consumption"
+    },
+    {
+      "interface": "SubDef",
+      "implementationKeyword": "sub",
+      "pattern": "sub\\s+(\\w+)\\s*\\{",
+      "description": "Subroutine/method implementation"
+    },
+    {
+      "interface": "MooseHas",
+      "implementationKeyword": "has",
+      "pattern": "has\\s+['\"]?(\\w+)['\"]?\\s*=>",
+      "description": "Moose attribute declaration"
+    }
+  ],
   "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
+    "interface": [
+      "package",
+      "use base",
+      "use parent",
+      "with (role)",
+      "@ISA"
+    ],
+    "implementation": [
+      "sub",
+      "has",
+      "extends",
+      "with",
+      "use Moose",
+      "use Moo"
+    ]
   }
 }

package/data/implementation/pgsql.json

@@ -0,0 +1,24 @@
+{
+  "language": "pgsql",
+  "implementationPatterns": [
+    {
+      "name": "Table",
+      "pattern": "CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(\\w+)",
+      "captureGroup": 1,
+      "type": "class"
+    },
+    {
+      "name": "Function",
+      "pattern": "CREATE\\s+(?:OR\\s+REPLACE\\s+)?FUNCTION\\s+(\\w+)",
+      "captureGroup": 1,
+      "type": "function"
+    },
+    {
+      "name": "View",
+      "pattern": "CREATE\\s+(?:MATERIALIZED\\s+)?VIEW\\s+(\\w+)",
+      "captureGroup": 1,
+      "type": "class"
+    }
+  ],
+  "keywords": {}
+}

package/data/implementation/pla.json

@@ -0,0 +1,36 @@
+{
+  "language": "pla",
+  "implementationPatterns": [
+    {
+      "interface": "Input",
+      "implementationKeyword": ".i",
+      "pattern": "\\.i\\s+(\\d+)",
+      "description": "Input declaration"
+    },
+    {
+      "interface": "Output",
+      "implementationKeyword": ".o",
+      "pattern": "\\.o\\s+(\\d+)",
+      "description": "Output declaration"
+    },
+    {
+      "interface": "ProductTerm",
+      "implementationKeyword": "term",
+      "pattern": "^([01-]+)\\s+([01-]+)",
+      "description": "Product term implementation"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      ".i (inputs)",
+      ".o (outputs)",
+      ".ilb",
+      ".ob"
+    ],
+    "implementation": [
+      "product terms",
+      ".p",
+      ".e"
+    ]
+  }
+}

package/data/implementation/postiats.json

@@ -0,0 +1,48 @@
+{
+  "language": "postiats",
+  "implementationPatterns": [
+    {
+      "interface": "FunDef",
+      "implementationKeyword": "implement",
+      "pattern": "implement\\s+(\\w+)",
+      "description": "Function implementation"
+    },
+    {
+      "interface": "FunDecl",
+      "implementationKeyword": "fun",
+      "pattern": "(?:fun|fn)\\s+(\\w+)\\s*(?:<[^>]+>)?\\s*\\(",
+      "description": "Function declaration"
+    },
+    {
+      "interface": "AbsType",
+      "implementationKeyword": "abstype",
+      "pattern": "abstype\\s+(\\w+)",
+      "description": "Abstract type declaration"
+    },
+    {
+      "interface": "Assume",
+      "implementationKeyword": "assume",
+      "pattern": "assume\\s+(\\w+)\\s*=",
+      "description": "Abstract type implementation (assume)"
+    },
+    {
+      "interface": "DataSort",
+      "implementationKeyword": "datasort",
+      "pattern": "datasort\\s+(\\w+)\\s*=",
+      "description": "Datasort definition"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "abstype",
+      "fun (signature)",
+      "extern fun"
+    ],
+    "implementation": [
+      "implement",
+      "assume",
+      "fn",
+      "fun"
+    ]
+  }
+}

package/data/implementation/powerquery.json

@@ -0,0 +1,42 @@
+{
+  "language": "powerquery",
+  "implementationPatterns": [
+    {
+      "interface": "LetBinding",
+      "implementationKeyword": "let",
+      "pattern": "let\\s+([\\w.]+)\\s*=",
+      "description": "Let binding (step definition)"
+    },
+    {
+      "interface": "SharedFunction",
+      "implementationKeyword": "shared",
+      "pattern": "shared\\s+(\\w+)\\s*=",
+      "description": "Shared/exported function"
+    },
+    {
+      "interface": "Section",
+      "implementationKeyword": "section",
+      "pattern": "section\\s+(\\w+)\\s*;",
+      "description": "Section (module) declaration"
+    },
+    {
+      "interface": "TypeDecl",
+      "implementationKeyword": "type",
+      "pattern": "type\\s+(\\w+)\\s*=\\s*type",
+      "description": "Custom type definition"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "section",
+      "type",
+      "shared"
+    ],
+    "implementation": [
+      "let...in",
+      "shared",
+      "each",
+      "(x) => x"
+    ]
+  }
+}

package/data/implementation/powershell.json

@@ -1,9 +1,48 @@
 {
   "language": "powershell",
-  "implementationPatterns": [],
+  "implementationPatterns": [
+    {
+      "interface": "Class",
+      "implementationKeyword": "class",
+      "pattern": "class\\s+(\\w+)(?:\\s*:\\s*\\w+)?\\s*\\{",
+      "description": "PowerShell class definition"
+    },
+    {
+      "interface": "ClassInherit",
+      "implementationKeyword": ":",
+      "pattern": "class\\s+(\\w+)\\s*:\\s*(\\w+)",
+      "description": "Class inheriting base class or implementing interface"
+    },
+    {
+      "interface": "Function",
+      "implementationKeyword": "function",
+      "pattern": "function\\s+(\\w[\\w-]*)\\s*(?:\\([^)]*\\))?\\s*\\{",
+      "description": "Function definition"
+    },
+    {
+      "interface": "CmdletBinding",
+      "implementationKeyword": "[CmdletBinding()]",
+      "pattern": "\\[CmdletBinding\\(\\)\\]",
+      "description": "Advanced function (cmdlet implementation)"
+    },
+    {
+      "interface": "Enum",
+      "implementationKeyword": "enum",
+      "pattern": "enum\\s+(\\w+)\\s*\\{",
+      "description": "Enum type definition"
+    }
+  ],
   "keywords": {
     "interface": [
-      "class"
+      "class",
+      "interface",
+      "[CmdletBinding()]"
+    ],
+    "implementation": [
+      "class",
+      "function",
+      "enum",
+      "filter"
     ]
   }
 }

package/data/implementation/protobuf.json

@@ -1,9 +1,48 @@
 {
   "language": "protobuf",
-  "implementationPatterns": [],
+  "implementationPatterns": [
+    {
+      "interface": "Service",
+      "implementationKeyword": "service",
+      "pattern": "service\\s+(\\w+)\\s*\\{",
+      "description": "gRPC service definition"
+    },
+    {
+      "interface": "RPC",
+      "implementationKeyword": "rpc",
+      "pattern": "rpc\\s+(\\w+)\\s*\\(",
+      "description": "RPC method definition within service"
+    },
+    {
+      "interface": "Message",
+      "implementationKeyword": "message",
+      "pattern": "message\\s+(\\w+)\\s*\\{",
+      "description": "Message type definition"
+    },
+    {
+      "interface": "Enum",
+      "implementationKeyword": "enum",
+      "pattern": "enum\\s+(\\w+)\\s*\\{",
+      "description": "Enum type definition"
+    },
+    {
+      "interface": "Oneof",
+      "implementationKeyword": "oneof",
+      "pattern": "oneof\\s+(\\w+)\\s*\\{",
+      "description": "Oneof field group"
+    }
+  ],
   "keywords": {
     "interface": [
-      "service"
+      "service",
+      "message",
+      "enum"
+    ],
+    "implementation": [
+      "rpc",
+      "message",
+      "oneof",
+      "extend"
     ]
   }
 }

package/data/implementation/python.json

@@ -1,10 +1,57 @@
 {
   "language": "python",
-  "implementationPatterns": [],
+  "implementationPatterns": [
+    {
+      "interface": "ClassInherit",
+      "implementationKeyword": "class",
+      "pattern": "class\\s+(\\w+)\\s*\\(([\\w.,\\s]+)\\)\\s*:",
+      "description": "Class inheriting from base class(es)"
+    },
+    {
+      "interface": "ABC",
+      "implementationKeyword": "ABC",
+      "pattern": "class\\s+(\\w+)\\s*\\(.*ABC.*\\)\\s*:",
+      "description": "Abstract base class implementation"
+    },
+    {
+      "interface": "Protocol",
+      "implementationKeyword": "Protocol",
+      "pattern": "class\\s+(\\w+)\\s*\\(.*Protocol.*\\)\\s*:",
+      "description": "Protocol (structural typing) implementation"
+    },
+    {
+      "interface": "AbstractMethod",
+      "implementationKeyword": "@abstractmethod",
+      "pattern": "@abstractmethod\\s*\\ndef\\s+(\\w+)",
+      "description": "Abstract method declaration"
+    },
+    {
+      "interface": "Register",
+      "implementationKeyword": "register",
+      "pattern": "(\\w+)\\.register\\s*\\((\\w+)\\)",
+      "description": "ABC virtual subclass registration"
+    },
+    {
+      "interface": "Mixin",
+      "implementationKeyword": "Mixin",
+      "pattern": "class\\s+(\\w+Mixin)\\s*(?:\\([^)]*\\))?\\s*:",
+      "description": "Mixin class definition"
+    }
+  ],
   "keywords": {
     "interface": [
+      "ABC",
+      "ABCMeta",
+      "Protocol",
+      "@abstractmethod",
+      "abstract"
+    ],
+    "implementation": [
       "class",
-      "Protocol"
+      "def",
+      "register",
+      "Mixin",
+      "super()"
     ]
   }
 }

package/data/implementation/qsharp.json

@@ -0,0 +1,49 @@
+{
+  "language": "qsharp",
+  "implementationPatterns": [
+    {
+      "interface": "Operation",
+      "implementationKeyword": "operation",
+      "pattern": "operation\\s+(\\w+)\\s*\\(",
+      "description": "Quantum operation implementation"
+    },
+    {
+      "interface": "Function",
+      "implementationKeyword": "function",
+      "pattern": "function\\s+(\\w+)\\s*\\(",
+      "description": "Classical function implementation"
+    },
+    {
+      "interface": "Newtype",
+      "implementationKeyword": "newtype",
+      "pattern": "newtype\\s+(\\w+)\\s*=",
+      "description": "User-defined type"
+    },
+    {
+      "interface": "Adjoint",
+      "implementationKeyword": "adjoint",
+      "pattern": "adjoint\\s+(auto|self|controlled|\\.\\.\\.)\\s*;",
+      "description": "Adjoint specialization implementation"
+    },
+    {
+      "interface": "Controlled",
+      "implementationKeyword": "controlled",
+      "pattern": "controlled\\s+(auto|\\.\\.\\.)\\s*;",
+      "description": "Controlled specialization implementation"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "operation (signature)",
+      "function (signature)",
+      "newtype"
+    ],
+    "implementation": [
+      "operation...{}",
+      "function...{}",
+      "body",
+      "adjoint",
+      "controlled"
+    ]
+  }
+}

package/data/implementation/r.json

@@ -0,0 +1,54 @@
+{
+  "language": "r",
+  "implementationPatterns": [
+    {
+      "interface": "S3Method",
+      "implementationKeyword": "function",
+      "pattern": "(\\w+)\\.(\\w+)\\s*<-\\s*function",
+      "description": "S3 method dispatch implementation (generic.class)"
+    },
+    {
+      "interface": "S4Class",
+      "implementationKeyword": "setClass",
+      "pattern": "setClass\\s*\\(\\s*[\"'](\\w+)[\"']",
+      "description": "S4 class definition"
+    },
+    {
+      "interface": "S4Method",
+      "implementationKeyword": "setMethod",
+      "pattern": "setMethod\\s*\\(\\s*[\"'](\\w+)[\"']",
+      "description": "S4 method implementation"
+    },
+    {
+      "interface": "R5Class",
+      "implementationKeyword": "setRefClass",
+      "pattern": "setRefClass\\s*\\(\\s*[\"'](\\w+)[\"']",
+      "description": "R5 reference class definition"
+    },
+    {
+      "interface": "R6Class",
+      "implementationKeyword": "R6Class",
+      "pattern": "R6Class\\$new\\s*\\(|R6::R6Class\\s*\\$\\s*new",
+      "description": "R6 class definition"
+    },
+    {
+      "interface": "S4Generic",
+      "implementationKeyword": "setGeneric",
+      "pattern": "setGeneric\\s*\\(\\s*[\"'](\\w+)[\"']",
+      "description": "S4 generic function declaration (interface)"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "setGeneric",
+      "setClass",
+      "UseMethod"
+    ],
+    "implementation": [
+      "setMethod",
+      "setRefClass",
+      "R6Class$new",
+      "generic.class <- function"
+    ]
+  }
+}

package/data/implementation/razor.json

@@ -0,0 +1,48 @@
+{
+  "language": "razor",
+  "implementationPatterns": [
+    {
+      "interface": "Component",
+      "implementationKeyword": "@inherits",
+      "pattern": "@inherits\\s+([\\w.]+)",
+      "description": "Component inheriting base class"
+    },
+    {
+      "interface": "Implements",
+      "implementationKeyword": "@implements",
+      "pattern": "@implements\\s+([\\w.]+)",
+      "description": "Component implementing interface"
+    },
+    {
+      "interface": "CodeBlock",
+      "implementationKeyword": "@code",
+      "pattern": "@code\\s*\\{",
+      "description": "Component code block"
+    },
+    {
+      "interface": "Section",
+      "implementationKeyword": "@section",
+      "pattern": "@section\\s+(\\w+)\\s*\\{",
+      "description": "Layout section implementation"
+    },
+    {
+      "interface": "TypeParam",
+      "implementationKeyword": "@typeparam",
+      "pattern": "@typeparam\\s+(\\w+)",
+      "description": "Generic type parameter"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "@inherits",
+      "@implements",
+      "@typeparam"
+    ],
+    "implementation": [
+      "@code {}",
+      "@section",
+      "@inherits",
+      "@implements"
+    ]
+  }
+}