periplus-map 0.2.1__py3-none-any.whl

periplus/packs/drupal@0.1.0/field/field_storage_code.yaml

@@ -0,0 +1,39 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — field storage created by PHP. One rule.
+
+needs:
+  types:
+  - drupal.field_storage
+rules:
+- rule: field_storage_from_code
+  reads: file
+  in:
+  - custom_module
+  match:
+    static_call: Drupal\field\Entity\FieldStorageConfig::create
+    argument: 0
+  id: &id001
+    from:
+    - argument_key: entity_type
+    - argument_key: field_name
+    template: field.storage.{entity_type}.{field_name}
+    on_miss: unresolved
+  emits:
+  - node:
+      type: drupal.field_storage
+  confidence: declared
+- rule: field_storage_from_code_edges
+  reads: file
+  in:
+  - custom_module
+  match:
+    static_call: Drupal\field\Entity\FieldStorageConfig::create
+    argument: 0
+  emits:
+  - edge:
+      kind: declares
+      from: enclosing_callable
+      to: this_node
+  confidence: declared
+  id: *id001

periplus/packs/drupal@0.1.0/field/field_storage_config.yaml

@@ -0,0 +1,24 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — field storage from a config file. One rule.
+
+needs:
+  types: [drupal.field_storage]
+
+rules:
+
+  - rule: field_storage_from_config
+    reads: file
+    in: [config, module_config]
+    match:
+      file: "field.storage.*"
+      filetype: yaml
+    id:
+      from: file_stem
+    emits:
+      - node: {type: drupal.field_storage}
+      - attribute: {name: field_type,  from: {key: type}}
+      - attribute: {name: cardinality, from: {key: cardinality}}
+    confidence: declared
+    # Verified: field.storage.block_content.body.yml, and the six the test modules ship as
+    # field.storage.block_content.field_tw_*.yml.

periplus/packs/drupal@0.1.0/form/form.yaml

@@ -0,0 +1,48 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — declares the Form API types and edges. Finds nothing.
+#
+# Under php alone every class here is php.class and every method is php.method. Adding this
+# pack keeps every id and refines every type to a descendant. That is the monotonic layering
+# check, and it is testable by running twice and diffing.
+#
+# Verified by grep over core lib and modules: no class implements both an entity interface
+# and a form interface. The two families are disjoint, so a class can never match both — a
+# form that edits a node is not a node.
+#
+# The collision that IS real sits inside the form family. EntityForm satisfies both
+# "reaches FormInterface" and "reaches EntityFormInterface", so both rules fire. The parent
+# declarations below make the most specific match win, and reserve refusal for genuine
+# ambiguity.
+
+node_types:
+
+  - name: drupal.form
+    parent: php.class
+
+  - name: drupal.entity_form
+    parent: drupal.form
+
+  - name: drupal.content_entity_form
+    parent: drupal.entity_form
+
+  - name: drupal.form_save
+    parent: php.method
+
+  - name: drupal.form_build
+    parent: php.method
+
+  - name: drupal.form_validate
+    parent: php.method
+
+  - name: drupal.form_submit
+    parent: php.method
+
+edge_kinds:
+
+  - kind: edits_entity
+    from: drupal.entity_form
+    to:   drupal.entity_type
+    # The endpoint is the entity TYPE, not the entity CLASS: an entity form
+    # edits an entity TYPE, which is its own node. Routing makes the binding at
+    # runtime, so the rule that fills this in is inferred, and it is not written yet.

periplus/packs/drupal@0.1.0/form/form_class.yaml

@@ -0,0 +1,50 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — classifies a class as a form. Three rules, all reading the map.
+#
+# Same reason as entity_class.yaml: a class becomes a form because of what it extends, and
+# the chain can pass through first-party base classes. Transitive classification is always a
+# map rule.
+#
+# About 258 classes in core modules reach drupal.form by extending FormBase, ConfirmFormBase,
+# EntityForm, ContentEntityForm, EntityDeleteForm or ConfigFormBase. Not one of them says
+# `implements FormInterface` at its own declaration site, so a rule matching the written
+# clause would match nothing real.
+
+needs:
+  types: [drupal.form, drupal.entity_form, drupal.content_entity_form]
+
+rules:
+
+  - rule: form_class
+    reads: map
+    match:
+      node_type: php.class
+      where:
+        - ancestor_reaches: "Drupal\\Core\\Form\\FormInterface"
+    emits:
+      - type: drupal.form
+    confidence: declared
+
+  - rule: entity_form_class
+    reads: map
+    match:
+      node_type: php.class
+      where:
+        - ancestor_reaches: "Drupal\\Core\\Entity\\EntityFormInterface"
+    emits:
+      - type: drupal.entity_form
+    confidence: declared
+
+  - rule: content_entity_form_class
+    reads: map
+    match:
+      node_type: php.class
+      where:
+        - ancestor_reaches: "Drupal\\Core\\Entity\\ContentEntityFormInterface"
+    emits:
+      - type: drupal.content_entity_form
+    confidence: declared
+    # Verified in a private Drupal site: 1 class extends ContentEntityForm, 1 extends
+    # ConfigFormBase. Small, and the rule that finds them is the same one that would find
+    # 258 in core.

periplus/packs/drupal@0.1.0/form/form_id.yaml

@@ -0,0 +1,48 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — the form's own id, from getFormId. One rule, reading the map.
+#
+# An entity type's id is a literal in an attribute or annotation, so it resolves every time.
+# A form's id comes from a method return, and usually that is also a literal — but not
+# always, and the exceptions are permanent rather than a pack needing improvement.
+#
+# Counted in core lib and modules: 274 getFormId() bodies return something. 266 return a
+# plain string literal. 8 compute it:
+#   RevisionRevertForm.php:106   $this->revision->getEntityTypeId() . '_revision_revert'
+#   RevisionDeleteForm.php:101   $this->revision->getEntityTypeId() . '_revision_delete'
+#   FileUploadForm.php:119       $this->getBaseFormId() . '_upload'
+#   OEmbedForm.php:76            $this->getBaseFormId() . '_oembed'
+#   JSInteractionTestForm.php:20 __CLASS__
+#   StubForm.php:48              $this->formId
+#
+# 97% resolvable is the useful number. Gaps being the exception is what makes an unresolved
+# count worth reading at all.
+
+needs:
+  types: [drupal.form]
+
+rules:
+
+  - rule: form_id_from_method_return
+    reads: map
+    match:
+      node_type: php.method
+      where:
+        - name: getFormId
+        - contained_by_type: drupal.form
+    id:
+      from: method_return_literal
+      must_be: string_literal
+      on_miss: unresolved
+    emits:
+      - attribute: {name: form_id, target: containing_node}
+    confidence: declared
+    # `reads: map` because the class has to be known to be a form first, and that is a map
+    # rule's output. Deciding literal-versus-not is a check, not a judgment, so no model is
+    # involved.
+    #
+    # It emits an ATTRIBUTE on the class, not a node. The form id is a second name for a
+    # thing already in the map, unlike an entity type id, which is referenced by config that
+    # never names the class. Nothing in a Drupal codebase references a form by its form id
+    # from another file — the id is used at runtime by hook_form_FORM_ID_alter, which is a
+    # function NAME, not a reference. That is a claim worth checking before it is relied on.

periplus/packs/drupal@0.1.0/form/form_methods.yaml

@@ -0,0 +1,39 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — the form lifecycle methods. Four rules, all reading the map.
+#
+# Each is a method name that means something only inside a form. The containing class's type
+# is what decides it, and that type is itself assigned by a map rule, so these run a pass
+# later again.
+
+needs:
+  types: [drupal.form, drupal.entity_form]
+
+rules:
+
+  - rule: form_build
+    reads: map
+    match: {node_type: php.method, where: [{name: buildForm}, {contained_by_type: drupal.form}]}
+    emits: [{type: drupal.form_build}]
+    confidence: declared
+
+  - rule: form_validate
+    reads: map
+    match: {node_type: php.method, where: [{name: validateForm}, {contained_by_type: drupal.form}]}
+    emits: [{type: drupal.form_validate}]
+    confidence: declared
+
+  - rule: form_submit
+    reads: map
+    match: {node_type: php.method, where: [{name: submitForm}, {contained_by_type: drupal.form}]}
+    emits: [{type: drupal.form_submit}]
+    confidence: declared
+
+  - rule: form_save
+    reads: map
+    match: {node_type: php.method, where: [{name: save}, {contained_by_type: drupal.entity_form}]}
+    emits: [{type: drupal.form_save}]
+    confidence: declared
+    # The pair that makes the point. EntityBase.php:368 and EntityForm.php:293 are both
+    # called `save`. One becomes drupal.entity_save, the other drupal.form_save, and the
+    # only thing separating them is the containing class's type.

periplus/packs/drupal@0.1.0/hook/hook.yaml

@@ -0,0 +1,8 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — declares the hook implementation type.
+
+node_types:
+
+  - name: drupal.hook_implementation
+    parent: php.method

periplus/packs/drupal@0.1.0/hook/hook_attribute.yaml

@@ -0,0 +1,28 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — hook implementations declared by the Hook attribute. One rule.
+
+needs:
+  types: [drupal.hook_implementation]
+
+rules:
+
+  - rule: hook_from_attribute
+    reads: file
+    in: [custom_module, custom_theme]
+    match:
+      attribute: "Drupal\\Core\\Hook\\Attribute\\Hook"
+      where:
+        - applies_to: method_declaration
+    emits:
+      - type: drupal.hook_implementation
+      - attribute: {name: hook, from: {attribute_argument: 0}}
+    confidence: declared
+    # BlockWaysHooks.php:25-26. A type refinement of php.method, so the id does not change
+    # and every edge the php pack emitted still lands.
+    #
+    # The hook being implemented is an attribute, not a node, and that is unsettled. Nothing
+    # first-party ever declares a hook — core does, in documentation — so a hook node would
+    # exist only because something referenced it, which is exactly when the boundary rule
+    # says a boundary node should be emitted. So this is probably wrong as written, and one
+    # hook implementation is not enough evidence to design against.

periplus/packs/drupal@0.1.0/module/module.yaml

@@ -0,0 +1,8 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — declares the module type.
+
+node_types:
+
+  - name: drupal.module
+    id_namespace: drupal.module

periplus/packs/drupal@0.1.0/module/module_info.yaml

@@ -0,0 +1,50 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — the module, from its info file. One rule.
+
+needs:
+  types:
+  - drupal.module
+rules:
+- rule: module_from_info_file
+  reads: file
+  in:
+  - custom_module
+  match:
+    file: '*.info'
+    filetype: yaml
+    where:
+    - key:
+        name: type
+        equals: module
+  id: &id001
+    from: file_stem
+  emits:
+  - node:
+      type: drupal.module
+  - attribute:
+      name: name
+      from:
+        key: name
+  confidence: declared
+- rule: module_from_info_file_edges
+  reads: file
+  in:
+  - custom_module
+  match:
+    file: '*.info'
+    filetype: yaml
+    where:
+    - key:
+        name: type
+        equals: module
+  emits:
+  - edge:
+      kind: depends_on_module
+      from: this_node
+      to:
+        from:
+          key: dependencies
+        each: true
+  confidence: declared
+  id: *id001

periplus/packs/drupal@0.1.0/pack.yaml

@@ -0,0 +1,184 @@
+$schema: "https://periplus.dev/schema/0/pack-manifest.schema.json"
+
+# Drupal pack — fragment
+#
+# Not a Drupal pack. A companion to the php pack that exercises what a dependent pack has
+# to do, using three of Drupal's APIs as the case, and deliberately leaving a fourth dark.
+#
+#   configured: Entity API, Form API, Cache API
+#   dark:       Event Subscriber API
+#
+# The dark one is not an oversight. It is the test for what happens when first-party code
+# leans on something no pack describes, which is the ordinary state of any real codebase.
+#
+# Every Drupal claim below was read from drupal-cms on 2026-08-28 and carries its file and
+# line. Nothing here is recalled.
+
+pack: drupal
+version: 0.1.0
+depends: [php, yaml]
+# Same mechanism as javascript -> react -> nextjs. Nothing marks this as a "framework
+# pack"; it is a pack that depends on another pack.
+#
+# Two languages rather than a layer on one, as transcribing the
+# block_ways map showed. A Drupal codebase is PHP and YAML in roughly equal measure, and with php
+# alone this pack declared config rules it could never run: `files` claimed no .yml, so no
+# .yml was ever opened and every config rule matched nothing without erroring.
+#
+# The alternative was a second `grammar:` block on this pack, which is wrong. A domain pack
+# that owns a language means every domain pack touching YAML re-declares the same grammar
+# and they drift. Instead the grammar follows the file extension, and the extension belongs
+# to whichever pack claimed it — so a `find` rule naming config/install/*.yml needs no
+# grammar field at all.
+
+# ======================================================================================
+# NAMED FOLDERS
+#
+# A rule says `in: [config]`. It never writes a path. The path lives here, once, and the
+# project settings file overrides it for one repository without touching a rule.
+#
+# Proved necessary: the default below is wrong for the codebase we tested
+# against, where settings.php:882 puts exported config at ./config/default. Under a rule
+# with the path baked in, that is a pack edit. Under a name, it is one line of settings.
+# ======================================================================================
+folders:
+  config:        ./config/sync        # exported configuration
+  custom_module: ./web/modules/custom
+  custom_theme:  ./web/themes/custom
+
+  # Relative to another folder, not to the root. A module ships its own config, and the
+  # path only means anything inside whatever custom_module resolves to.
+  module_config: "{custom_module}/*/config/install"
+
+files:
+  extends: [php, yaml]
+  add_extensions: [module, inc, install, theme, profile, engine]
+  # None of these say "PHP" by convention. A mapper that cannot be told they are PHP maps
+  # almost nothing in a Drupal codebase.
+
+  add_excludes:
+    # Every path here is PHP by extension, so the PHP pack would open it. None of it is
+    # code anyone wrote to be read. Excluded rather than bounded: nothing in these files
+    # should ever be a node, not even the target of a reference.
+    #
+    # Verified present in drupal-cms on 2026-08-28.
+    - "web/sites/*/settings.php"           # web/sites/default/settings.php
+    - "web/sites/*/settings.*.php"         # web/sites/default/settings.ddev.php
+    - "web/sites/*/default.settings.php"   # the template shipped by core
+    - "web/sites/*/services.yml"
+    - "web/sites/*/default.services.yml"
+    # Per-environment configuration, and the first two hold database credentials and the
+    # hash salt. The map is committed and diffed in a pull request, so this is the one
+    # exclusion that is a security rule and not a tidiness rule.
+
+    - "web/sites/*/files/**"
+    # The public files directory. User uploads, generated assets, and on some sites
+    # compiled Twig. Nothing here is authored.
+
+    - "web/sites/simpletest/**"
+    # Test-run scratch space, created and destroyed by the test runner.
+
+# ======================================================================================
+# BOUNDARY
+#
+# Entity API is not "a boundary". Every class listed below is the boundary. What separates
+# Entity API from Event Subscriber API is only that this pack ships knowledge about one of them.
+# Two mechanisms, kept apart, which is what lets the dark case degrade instead of fail.
+# ======================================================================================
+boundary:
+  # A boundary node enters the map because first-party code refers to it, never because a
+  # pack knows about it. An edge end that lands on a listed name becomes a declared node this
+  # pack drew; a listed name nothing reaches stays out of the map, so the map stays about this
+  # repository.
+  framework:
+    type: php.class_like
+    ancestry: [inherits, implements]
+
+  # ------------------------------------------------------------------------------------
+  # The hierarchy the ancestry kinds walk toward a listed name.
+  #
+  # This is why "not mapped" and "not read" are different operations. A custom entity
+  # almost never writes `implements EntityInterface`; it writes `extends
+  # ContentEntityBase`, and the interface is two hops up inside core. A rule matching the
+  # written clause would match nothing real.
+  #
+  # Both families are diamonds. Verified:
+  #
+  #   ContentEntityForm extends EntityForm implements ContentEntityFormInterface
+  #     ContentEntityForm.php:16 / ContentEntityFormInterface.php:11
+  #   EntityForm extends FormBase implements EntityFormInterface      EntityForm.php:18
+  #   ConfirmFormBase extends FormBase implements ConfirmFormInterface
+  #     ConfirmFormBase.php:8
+  #   FormBase implements FormInterface, ContainerInjectionInterface   FormBase.php:45
+  #   EntityFormInterface extends BaseFormIdInterface        EntityFormInterface.php:14
+  #   BaseFormIdInterface extends FormInterface              BaseFormIdInterface.php:11
+  #   => EntityForm reaches FormInterface twice: via FormBase, and via
+  #      EntityFormInterface -> BaseFormIdInterface. Resolution must dedupe.
+  #
+  #   ContentEntityBase extends EntityBase implements ContentEntityInterface, ...
+  #     ContentEntityBase.php:20
+  #   EntityBase implements EntityInterface                  EntityBase.php:21
+  #   ContentEntityInterface extends FieldableEntityInterface, ...
+  #     ContentEntityInterface.php:24
+  #   FieldableEntityInterface extends EntityInterface  FieldableEntityInterface.php:23
+  #   ConfigEntityInterface extends EntityInterface, ...  ConfigEntityInterface.php:14
+  #   ConfigEntityBase extends EntityBase implements ConfigEntityInterface
+  #     ConfigEntityBase.php:26
+  #   => same diamond on the entity side.
+  # ------------------------------------------------------------------------------------
+    # Each name below is a boundary with no classification (~).
+    names:
+      # Form API
+      "Drupal\\Core\\Form\\FormInterface": ~
+      "Drupal\\Core\\Form\\FormBase": ~
+      "Drupal\\Core\\Form\\ConfirmFormInterface": ~
+      "Drupal\\Core\\Form\\ConfirmFormBase": ~
+      "Drupal\\Core\\Form\\BaseFormIdInterface": ~
+      "Drupal\\Core\\Entity\\EntityFormInterface": ~
+      "Drupal\\Core\\Entity\\EntityForm": ~
+      "Drupal\\Core\\Entity\\ContentEntityFormInterface": ~
+      "Drupal\\Core\\Entity\\ContentEntityForm": ~
+
+      # Entity API
+      "Drupal\\Core\\Entity\\EntityInterface": ~
+      "Drupal\\Core\\Entity\\EntityBase": ~
+      "Drupal\\Core\\Entity\\FieldableEntityInterface": ~
+      "Drupal\\Core\\Entity\\ContentEntityInterface": ~
+      "Drupal\\Core\\Entity\\ContentEntityBase": ~
+      "Drupal\\Core\\Config\\Entity\\ConfigEntityInterface": ~
+      "Drupal\\Core\\Config\\Entity\\ConfigEntityBase": ~
+
+      # Cache API. Both are standalone: neither extends another interface.
+      #   CacheBackendInterface.php:16 / CacheTagsInvalidatorInterface.php:14
+      "Drupal\\Core\\Cache\\CacheBackendInterface": ~
+      "Drupal\\Core\\Cache\\CacheTagsInvalidatorInterface": ~
+
+  # ------------------------------------------------------------------------------------
+  # Deliberately NOT shipped, so the unknown path is exercised by real code.
+  #
+  # Nothing below appears in names. Each is referenced by first-party code in the
+  # worked example, so each becomes a boundary node whose state is `referenced` rather
+  # than `declared`: the edge kind is known, because `implements` is written at the site,
+  # but nothing describes what the target is.
+  #
+  #   Symfony\Component\EventDispatcher\EventSubscriberInterface
+  #     vendor/symfony/event-dispatcher/EventSubscriberInterface.php
+  #     11 first-party files implement it across the three example modules.
+  #
+  #   Drupal\Core\Entity\EntityTypeListenerInterface
+  #     core/lib/Drupal/Core/Entity/EntityTypeListenerInterface.php:8
+  #
+  #   Drupal\Core\Form\WorkspaceDynamicSafeFormInterface
+  #     core/lib/Drupal/Core/Form/WorkspaceDynamicSafeFormInterface.php:15
+  #
+  #   Drupal\Core\Entity\EntityPublishedInterface
+  #     core/lib/Drupal/Core/Entity/EntityPublishedInterface.php:10
+  #     Note this one extends EntityInterface. Leaving it out costs nothing, because
+  #     Redirect still types correctly as a content entity through ContentEntityBase.
+  #     That is graceful degradation demonstrated rather than claimed.
+  #
+  # The Plugin API is also dark, incidentally rather than by design: ControllerBase,
+  # PluginBase, QueueWorkerBase, DeriverBase, ActionBase, FieldItemBase and
+  # ContainerFactoryPluginInterface all appear in the example modules and none is
+  # described here. That is what a real first pack looks like.
+  # ------------------------------------------------------------------------------------

periplus/packs/drupal@0.1.0/plugin/plugin.yaml

@@ -0,0 +1,17 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — declares the field plugin types.
+
+node_types:
+
+  - name: drupal.field_type
+    parent: drupal.plugin
+    id_namespace: drupal.plugin.field_type
+
+  - name: drupal.field_widget
+    parent: drupal.plugin
+    id_namespace: drupal.plugin.field_widget
+
+  - name: drupal.field_formatter
+    parent: drupal.plugin
+    id_namespace: drupal.plugin.field_formatter

periplus/packs/drupal@0.1.0/plugin/plugin_annotation.yaml

@@ -0,0 +1,120 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# drupal pack — plugins declared by a docblock annotation. One rule per plugin type, and
+# they differ only in two values.
+#
+# Written to test whether twelve annotation classes need twelve mechanisms. They do not.
+# Every one is @Name(key = "value") in a docblock, so one grammar reads all of them, and a
+# rule differs from its neighbour by the annotation name and the type it emits.
+
+needs:
+  types:
+  - drupal.field_type
+  - drupal.field_widget
+  - drupal.field_formatter
+rules:
+- rule: field_type_from_annotation
+  reads: file
+  in:
+  - custom_module
+  match:
+    annotation: FieldType
+    grammar: doctrine-annotation
+    where:
+    - applies_to: class_declaration
+  id: &id001
+    from:
+      annotation_key: id
+    must_be: string_literal
+    template: drupal.plugin.field_type::{id}
+    on_miss: unresolved
+  emits:
+  - node:
+      type: drupal.field_type
+  confidence: declared
+- rule: field_widget_from_annotation
+  reads: file
+  in:
+  - custom_module
+  match:
+    annotation: FieldWidget
+    grammar: doctrine-annotation
+    where:
+    - applies_to: class_declaration
+  id: &id002
+    from:
+      annotation_key: id
+    must_be: string_literal
+    template: drupal.plugin.field_widget::{id}
+    on_miss: unresolved
+  emits:
+  - node:
+      type: drupal.field_widget
+  confidence: declared
+- rule: field_formatter_from_annotation
+  reads: file
+  in:
+  - custom_module
+  match:
+    annotation: FieldFormatter
+    grammar: doctrine-annotation
+    where:
+    - applies_to: class_declaration
+  id: &id003
+    from:
+      annotation_key: id
+    must_be: string_literal
+    template: drupal.plugin.field_formatter::{id}
+    on_miss: unresolved
+  emits:
+  - node:
+      type: drupal.field_formatter
+  confidence: declared
+- rule: field_type_from_annotation_edges
+  reads: file
+  in:
+  - custom_module
+  match:
+    annotation: FieldType
+    grammar: doctrine-annotation
+    where:
+    - applies_to: class_declaration
+  emits:
+  - edge:
+      kind: plugin_class
+      from: this_node
+      to: enclosing_class
+  confidence: declared
+  id: *id001
+- rule: field_widget_from_annotation_edges
+  reads: file
+  in:
+  - custom_module
+  match:
+    annotation: FieldWidget
+    grammar: doctrine-annotation
+    where:
+    - applies_to: class_declaration
+  emits:
+  - edge:
+      kind: plugin_class
+      from: this_node
+      to: enclosing_class
+  confidence: declared
+  id: *id002
+- rule: field_formatter_from_annotation_edges
+  reads: file
+  in:
+  - custom_module
+  match:
+    annotation: FieldFormatter
+    grammar: doctrine-annotation
+    where:
+    - applies_to: class_declaration
+  emits:
+  - edge:
+      kind: plugin_class
+      from: this_node
+      to: enclosing_class
+  confidence: declared
+  id: *id003