periplus-map 0.2.1__py3-none-any.whl

periplus/packs/drush_basic@0.0.1/command/command_attribute.yaml

@@ -0,0 +1,88 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A Drush command declared by the Command attribute on a method, named by the argument name.
+# Two rules because a rule that emits an edge emits no node, and two pairs because a match names
+# one full class: Drush's attribute, and the Consolidation one it extends, which a command file may
+# import instead.
+
+rules:
+- rule: command_from_attribute
+  reads: file
+  in:
+  - source
+  match:
+    attribute: Drush\Attributes\Command
+    filetype: php
+    where:
+    - applies_to: method_declaration
+  id:
+    from:
+      attribute_argument: name
+    must_be: string_literal
+  emits:
+  - node:
+      type: drush.command
+  confidence: declared
+- rule: command_from_attribute_edges
+  reads: file
+  in:
+  - source
+  match:
+    attribute: Drush\Attributes\Command
+    filetype: php
+    where:
+    - applies_to: method_declaration
+  id:
+    from:
+      attribute_argument: name
+    must_be: string_literal
+  emits:
+  - edge:
+      kind: command_method
+      from: this_node
+      to: enclosing_method
+  - edge:
+      kind: command_class
+      from: this_node
+      to: enclosing_class
+  confidence: declared
+- rule: command_from_consolidation_attribute
+  reads: file
+  in:
+  - source
+  match:
+    attribute: Consolidation\AnnotatedCommand\Attributes\Command
+    filetype: php
+    where:
+    - applies_to: method_declaration
+  id:
+    from:
+      attribute_argument: name
+    must_be: string_literal
+  emits:
+  - node:
+      type: drush.command
+  confidence: declared
+- rule: command_from_consolidation_attribute_edges
+  reads: file
+  in:
+  - source
+  match:
+    attribute: Consolidation\AnnotatedCommand\Attributes\Command
+    filetype: php
+    where:
+    - applies_to: method_declaration
+  id:
+    from:
+      attribute_argument: name
+    must_be: string_literal
+  emits:
+  - edge:
+      kind: command_method
+      from: this_node
+      to: enclosing_method
+  - edge:
+      kind: command_class
+      from: this_node
+      to: enclosing_class
+  confidence: declared

periplus/packs/drush_basic@0.0.1/pack.yaml

@@ -0,0 +1,29 @@
+$schema: "https://periplus.dev/schema/0/pack-manifest.schema.json"
+
+# Drush commands in the custom modules: each command, named by its name, as mymodule:sync, with
+# a command_method edge to the method that runs it and a command_class edge to that method's
+# class. A command is read from the Command attribute on a method, #[CLI\Command(name: '...')],
+# and from the @command tag in a method's docblock. A method that carries both is one node with
+# two locations, and its edges are found twice.
+#
+# Known gaps:
+# - The @command tag is read as text, because the engine reads a docblock annotation only in the
+#   form @Name(...). The engine allows one file type read as text per ending, so the tag is read
+#   through drupal_basic's drupal_php_text, inside its block_comment section. Its class is named from the file's path by Drupal's PSR-4 layout:
+#   <module>/src/A/B.php is Drupal\<module>\A\B. So its edges are inferred, and a file whose class
+#   is named otherwise gives edges to a method and a class that do not exist, as unresolved nodes.
+#   A tag outside a file below a src folder makes a node and no edge.
+# - The tag's method is the first function after the docblock's end, past one-line attributes
+#   and modifiers. An attribute split over lines between the docblock and the function makes the
+#   node and no edge. A tag inside a PHP string still makes a command.
+# - An attribute whose name is not the named argument name:, such as #[CLI\Command('x')], or is
+#   not a text literal, makes nothing and is listed under skipped.
+# - Aliases give nothing: the engine reads no item of an attribute's list argument, and the
+#   @aliases tag would need one rule per position in its list.
+# - Options, arguments, usages, hooks (#[CLI\Hook], @hook), topics and validators give nothing.
+# - A command class that is a service in a drush.services.yml file is mapped by drupal_basic as
+#   a service with its class; nothing joins that service to the command.
+pack: drush_basic
+version: 0.0.1
+depends: [drupal_basic, php_basic]
+

periplus/packs/eck_basic@0.0.1/bundle/eck_bundle_config.yaml

@@ -0,0 +1,56 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# An ECK bundle read from its config file eck.eck_type.<entity type>.<bundle> as the bundle
+# <entity type>.<bundle>, the id drupal_basic gives a field or display of it. The file names its
+# entity type only in its name, so both edges read it from the path value
+# eck_entity_type.
+
+rules:
+- rule: bundle_eck_from_config
+  reads: file
+  in:
+  - config
+  - module_config
+  match:
+    file: eck.eck_type.*
+    filetype: yml
+  id:
+    from: file_stem
+    normalize:
+    - {replace: '^eck\.eck_type\.', with: ''}
+  emits:
+  - node:
+      type: drupal.bundle
+  - attribute:
+      name: label
+      from:
+        key: name
+  confidence: declared
+- rule: bundle_eck_from_config_edges
+  reads: file
+  in:
+  - config
+  - module_config
+  match:
+    file: eck.eck_type.*
+    filetype: yml
+  id:
+    from: file_stem
+    normalize:
+    - {replace: '^eck\.eck_type\.', with: ''}
+  emits:
+  - edge:
+      kind: configured_by
+      from: this_node
+      to:
+        from:
+          key: type
+        template: 'eck.eck_type.{eck_entity_type}.{type}'
+  - edge:
+      kind: bundle_of
+      from: this_node
+      to:
+        from:
+          key: type
+        template: '{eck_entity_type}'
+  confidence: declared

periplus/packs/eck_basic@0.0.1/entity_type/eck_entity_type_config.yaml

@@ -0,0 +1,26 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# An ECK entity type read from its config file: a content entity type named by its id, with its
+# label. ECK defines no class for it, so it has no entity_class edge.
+
+rules:
+- rule: eck_entity_type_from_config
+  reads: file
+  in:
+  - config
+  - module_config
+  match:
+    file: eck.eck_entity_type.*
+    filetype: yaml
+  id:
+    from: file_stem
+    normalize:
+    - {replace: '^eck\.eck_entity_type\.', with: ''}
+  emits:
+  - node:
+      type: drupal.content_entity_type
+  - attribute:
+      name: label
+      from:
+        key: label
+  confidence: declared

periplus/packs/eck_basic@0.0.1/pack.yaml

@@ -0,0 +1,28 @@
+$schema: "https://periplus.dev/schema/0/pack-manifest.schema.json"
+
+# The Entity Construction Kit contributed module: each ECK entity type, from its config file, as
+# a content entity type with its label; and each ECK bundle, from its config file
+# eck.eck_type.<entity type>.<bundle>, as the bundle <entity type>.<bundle> with its label (key
+# name), a configured_by edge to that file and a bundle_of edge to its entity type.
+#
+# Known gaps: an ECK entity type's base field switches (uid, created, changed, title) and
+# standalone_url give nothing, and it has no entity_class edge, because ECK defines no class per
+# type. The bundle_of edge reads the entity type from the file name, not from a key, so a file
+# renamed by hand gives a wrong edge. A bundle's description gives nothing.
+#
+# The path value eck_entity_type is declared on yaml_basic's type yml, so the bundle rules match
+# filetype yml; a type of another name that claims the ending yml is refused.
+pack: eck_basic
+version: 0.0.1
+depends: [drupal_basic]
+files:
+  types:
+    # A bundle file names its entity type only in its file name, eck.eck_type.<entity type>.<bundle>.
+    yml:
+      endings: [yml]
+      reader: data
+      format: yaml
+      path_values:
+        eck_entity_type:
+          pattern: '^(?:.*/)?eck\.eck_type\.(?<name>[^./]+)\.[^/]+\.yml$'
+          template: '{name}'

periplus/packs/go@0.0.2/interfaces/satisfies.yaml

@@ -0,0 +1,47 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# go pack — implicit interface satisfaction. Two map rules.
+#
+# The case the two-bucket split was designed for. A Go type satisfies an interface by having
+# the right methods, says so nowhere, and the methods may sit in any file of the package. No
+# rule that reads one file can answer it.
+
+needs:
+  types:
+  - go.struct
+  - go.interface
+edge_kinds:
+- kind: has_receiver
+  from: go.method
+  to:
+  - go.struct
+  - go.interface
+- kind: satisfies
+  from: go.struct
+  to: go.interface
+rules:
+- rule: collect_method_set
+  reads: map
+  match:
+    node_type: go.struct
+    where:
+    - has_incoming_edge: has_receiver
+  emits:
+  - attribute:
+      name: method_set
+      from:
+        incoming_edges: has_receiver
+        value: signature
+  confidence: declared
+- rule: satisfies_interface
+  reads: map
+  match:
+    node_type: go.struct
+    where:
+    - method_set_covers: go.interface
+  emits:
+  - edge:
+      kind: satisfies
+      from: this_node
+      to: matched_node
+  confidence: declared

periplus/packs/go@0.0.2/pack.yaml

@@ -0,0 +1,51 @@
+$schema: "https://periplus.dev/schema/0/pack-manifest.schema.json"
+
+# go pack — SKETCH in the rule format.
+#
+# Converted as the test of whether the format written against PHP, YAML and Drupal holds for
+# a language that behaves differently in three ways: it declares no type relationships, it
+# takes part of every id from a file at the repository root, and it joins id parts with two
+# different separators in fixed positions.
+
+pack: go
+version: 0.0.2
+depends: []
+
+grammar:
+  provider: tree-sitter
+  provider_version: "0.26.13"
+  language: go
+  grammar_version: "0.23.4"
+  # UNVERIFIED: both numbers are placeholders in the shape the other packs use. Neither has
+  # been checked against a published release. Note also that tree-sitter's maintainers say
+  # to pin to a commit rather than a version, which no pack here does yet.
+
+folders:
+  source: ./
+
+files:
+  extensions: [go]
+  exclude: []
+
+identity:
+  qualified_name:
+    parts:
+      - from: manifest
+        file: go.mod
+        match: '^module\s+(\S+)'
+        as: module_path
+      - from: path
+        relative_to: manifest_dir
+        strip: filename
+        as: package_dir
+      - from: declared_name
+    join:
+      - between: [module_path, package_dir]
+        with: "/"
+      - between: [package_dir, declared_name]
+        with: "."
+    # Two separators in fixed positions, and a part that comes from neither the file being
+    # classified nor the pack: `module_path` is one line in go.mod at the repository root.
+    # A PHP file writes its own namespace; a Go file does not.
+  case_folding:
+    sensitive: [all]

periplus/packs/go@0.0.2/types/find_declarations.yaml

@@ -0,0 +1,137 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# go pack — finds the declarations. Five rules.
+#
+# Two of them match the same grammar node and are told apart by a child, which is the
+# `has_child` condition doing what `body_child` does for PHP.
+
+needs:
+  types:
+  - go.package
+  - go.func
+  - go.method
+  - go.struct
+  - go.interface
+rules:
+- rule: find_package
+  reads: file
+  in:
+  - source
+  match:
+    declaration: package_clause
+    name_child: package_identifier
+  id:
+    from: qualified_name
+  emits:
+  - node:
+      type: go.package
+  confidence: declared
+- rule: find_func
+  reads: file
+  in:
+  - source
+  match:
+    declaration: function_declaration
+    name_child: identifier
+  id:
+    from: qualified_name
+  emits:
+  - node:
+      type: go.func
+  confidence: declared
+- rule: find_struct
+  reads: file
+  in:
+  - source
+  match:
+    declaration: type_spec
+    name_child: type_identifier
+    where:
+    - has_child: struct_type
+  id:
+    from: qualified_name
+  emits:
+  - node:
+      type: go.struct
+  confidence: declared
+- rule: find_interface
+  reads: file
+  in:
+  - source
+  match:
+    declaration: type_spec
+    name_child: type_identifier
+    where:
+    - has_child: interface_type
+  id:
+    from: qualified_name
+  emits:
+  - node:
+      type: go.interface
+  - attribute:
+      name: method_set
+      from:
+        text: true
+        pattern: (?s)interface\s*\{(?P<body>.*?)\}
+        normalize:
+        - replace: interface\{\}
+          with: any
+        - replace: \n
+          with: ;
+        - replace: '[ \t]+'
+          with: ' '
+  confidence: declared
+- rule: find_method
+  reads: file
+  in:
+  - source
+  match:
+    declaration: method_declaration
+    name_child: field_identifier
+  id: &id001
+    from:
+    - module_path
+    - package_dir
+    - receiver_type
+    - declared_name
+    template: '{module_path}/{package_dir}.{receiver_type}.{declared_name}'
+  emits:
+  - node:
+      type: go.method
+  confidence: declared
+- rule: exported_by_capitalisation
+  reads: file
+  in:
+  - source
+  match:
+    declaration: identifier
+    where:
+    - name_matches: ^[A-Z]
+  emits:
+  - role: go.exported
+  confidence: declared
+- rule: find_method_edges
+  reads: file
+  in:
+  - source
+  match:
+    declaration: method_declaration
+    name_child: field_identifier
+  emits:
+  - edge:
+      kind: has_receiver
+      from: this_node
+      to:
+        from:
+          qualified: receiver_type
+      attributes:
+        signature:
+          from: text
+          pattern: func\s*\([^)]*\)\s*(?P<sig>\w+\s*\([^{]*)
+          normalize:
+          - replace: interface\{\}
+            with: any
+          - replace: \s+
+            with: ' '
+  confidence: declared
+  id: *id001

periplus/packs/go@0.0.2/types/node_types.yaml

@@ -0,0 +1,36 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# go pack — the node types. Finding them is in types/find_declarations.yaml.
+#
+# The abstractions are here because a finder needs them, and their absence was invisible
+# until one was asked for. A map whose types are all siblings cannot answer "every callable
+# here" — the query has nothing to descend. php declared php.callable from the start; this
+# sketch did not, and nothing complained until the map was queried.
+
+node_types:
+
+  - name: go.package
+    container: true
+
+  - name: go.callable
+    abstract: true
+
+  - name: go.func
+    parent: go.callable
+
+  - name: go.method
+    parent: go.callable
+
+  - name: go.type
+    abstract: true
+
+  - name: go.struct
+    parent: go.type
+    container: true
+
+  - name: go.interface
+    parent: go.type
+
+roles:
+
+  - name: go.exported

periplus/packs/go_basic@0.0.3/pack.yaml

@@ -0,0 +1,104 @@
+$schema: "https://periplus.dev/schema/0/pack-manifest.schema.json"
+
+# Known gaps. The basic Go pack maps every package-level function, every method under its
+# receiver type, and every struct and interface, each under its package's import path. It maps a
+# call written f(x) to the function, struct or interface of that name in the caller's package,
+# and pkg.F(x) to F under the import path pkg binds. A call into a package outside the project,
+# fmt.Println() or cobra.Execute() after "github.com/spf13/cobra/v2", is an unresolved function
+# named by the import path and the function: fmt.Println, github.com/spf13/cobra/v2.Execute.
+# What it does not map, today:
+# - A method call on a value, s.Serve(), makes no edge: s is bound by no import, so no step holds
+#   and the call is listed under skipped. A chained call, s.Self().Serve(), is skipped as not a
+#   written name; its inner call is a call of its own.
+# - A method expression, util.T.M(t), is an unresolved function example.com/app/util.T.M, beside
+#   the mapped method of that name, with no edge to the method.
+# - A generic call with type arguments, util.G[int](1), makes no edge and is not listed as skipped.
+# - A call in a package-level initialiser, var early = util.Make(), makes no edge: it is listed
+#   under skipped, as no enclosing declaration is mapped.
+# - An import binds its alias, else the last segment of its path less a trailing /vN, N 2 or more,
+#   or .vN: "gopkg.in/yaml.v3" binds yaml, "k8s.io/api/core/v1" binds v1. A package whose name
+#   differs, package other in folder naming, needs an alias: other.Thing() without one is
+#   skipped, and no edge reaches the mapped Thing.
+# - A blank or a dot import binds nothing: after . "unicode", unicode.IsUpper() is skipped as no
+#   step holds. A bare call of a name a dot import brings in, ToUpper(s), shows as an unresolved
+#   <package>.ToUpper in the caller's package.
+# - A local variable named like an imported package gives a false end: after
+#   url, err := url.Parse(s), url.String() is a calls edge to the unresolved net/url.String.
+# - A method call on a package-level variable gives a false unresolved function: os.Stdout.Fd()
+#   ends at os.Stdout.Fd, pflag.CommandLine.Parse() at github.com/spf13/pflag.CommandLine.Parse,
+#   not at a method of the variable's type.
+# - An edge's occurrences counts lines: two calls of one target on one line count once.
+# - A call of a local function variable or parameter, fn(), shows as a call of <package>.fn. It
+#   is unresolved, unless the package declares fn: then the edge lands on that declaration, falsely.
+# - A conversion to a named non-struct type, byName(x), also shows as an unresolved function.
+# - A call of a project function named like a Go builtin or predeclared type, such as min, max or
+#   len, makes no edge. Those names are skipped before any lookup.
+# - A type declared inside a function gets a package-level id, as if declared at the top. Two
+#   functions that each declare a type T give one node T holding both locations.
+# - Build constraints are not read, so every platform file is mapped. Plat declared in a_linux.go
+#   and a_windows.go of one package is one node holding both locations, with no problem reported.
+# - Test files (*_test.go) are not read, nor folders named testdata or vendor. So vendored
+#   dependencies are not mapped.
+# - A folder or a .go file whose name starts with _ or a dot is not read. Go still builds such a
+#   folder when another package imports it by path, so a call into it, hid.Secret() after
+#   hid "example.com/app/_hidden", ends at an unresolved example.com/app/_hidden.Secret.
+# - A nested module, a folder with its own go.mod, is mapped under the outer module as
+#   <module>/<folder>, which is not its real import path.
+# The module path is not read from go.mod. Give it in the project settings as values.module, such
+# as module: github.com/spf13/cobra, and run periplus at the module's root. Without it, periplus
+# map exits 19 and writes no map, with "the template {module}/{file}, which names module, no
+# capture of its pattern and no settings value". If the module sits in
+# a subfolder of the project, that folder's name becomes part of every package path: name the
+# folder as the module path's last segment and set values.module to the path without it, or move
+# the settings to the module's root.
+# The grammar is the optional extra go. Without it, periplus map exits 28 with "pins
+# tree-sitter-go 0.25.0, and the version found is none"; install periplus-map[go].
+pack: go_basic
+version: 0.0.3
+depends: []
+grammar:
+  provider: tree-sitter
+  provider_version: "0.26.0"
+  language: go
+  grammar_version: "0.25.0"
+# The whole project at any depth. The project root is the Go module's root.
+folders:
+  source: ./**
+files:
+  # A _test.go file is test code, often a second package, a testdata folder holds fixtures, a
+  # vendor folder holds dependencies. The go tool ignores a .go file whose name starts with _ or
+  # a dot, and ./... skips such a folder, though Go builds one a package imports by path.
+  exclude: ['**/*_test.go', '**/testdata/**', '**/vendor/**', '**/_*/**', '**/.*/**', '**/_*.go', '**/.*.go']
+  types:
+    go:
+      endings: [go]
+      reader: tree
+      path_values:
+        # The import path of a file's package: the module path from the settings, then the
+        # file's folder below the module root. main.go is <module>, doc/md_docs.go <module>/doc.
+        pkg:
+          pattern: '^(?<file>.+)$'
+          template: '{module}/{file}'
+          normalize:
+          - {replace: '/[^/]+$', with: ''}
+identity:
+  # A full name is the package's import path, a dot, and the declared name.
+  qualified_name:
+    parts: [namespace, declared_name]
+    separator: "."
+  namespace:
+    path_value: pkg
+  # A call's name is written when it is an identifier, f(), or a selector of identifiers,
+  # x.f(). interpreted_string_literal_content is an import's path.
+  written_names: [identifier, selector_expression, field_identifier, interpreted_string_literal_content]
+  # f() is in the file's own package, even when f is also an import's bound name: in Go a bare
+  # name in a call is never a package. x.f() takes the import path x binds. A dotted name whose
+  # first segment no import binds, as a method on a value, has no step that holds.
+  resolve:
+  - prefix_bare_with: namespace
+  - bound_first_segment
+  # A call's arguments are the named children of its arguments field, by position. Its text
+  # literals are an interpreted and a raw string, each with its own node of text.
+  call_arguments: arguments
+  call_literals: [interpreted_string_literal, raw_string_literal]
+  call_literal_content: [interpreted_string_literal_content, raw_string_literal_content]

periplus/packs/go_basic@0.0.3/rules/calls.yaml

@@ -0,0 +1,25 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+rules:
+# f(x) in a function or method: an edge to <package>.f; pkg.F(x): to <import path>.F, through the
+# grammar's resolve. The end gives no resolve of its own, since its steps would run again on the
+# resolved name. whole_written skips a chained call, a.B().C(). Builtins and predeclared
+# conversions make nothing.
+- rule: calls
+  reads: file
+  in: [source]
+  match:
+    reference: call_expression
+    name_child: function
+    filetype: go
+    whole_written: true
+    skip_names: [append, cap, clear, close, complex, copy, delete, imag, len, make, max, min, new,
+      panic, print, println, real, recover, any, bool, byte, comparable, complex64, complex128,
+      error, float32, float64, int, int8, int16, int32, int64, rune, string, uint, uint8, uint16,
+      uint32, uint64, uintptr]
+  emits:
+  - edge:
+      kind: calls
+      from: enclosing_declaration
+      to: {types: [go.function, go.struct, go.interface], on_miss: unresolved}
+  confidence: declared

periplus/packs/go_basic@0.0.3/rules/declarations.yaml

@@ -0,0 +1,40 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+rules:
+# func Name(...): <package import path>.Name
+- rule: function
+  reads: file
+  in: [source]
+  match: {declaration: function_declaration, name_child: name, filetype: go}
+  id: {from: qualified_name}
+  emits: [{node: {type: go.function}}]
+  confidence: declared
+# func (c *Command) Name(...): <package>.Command.Name. The receiver field is the whole
+# parenthesised list; normalize drops the variable, the star and any type parameters.
+- rule: method
+  reads: file
+  in: [source]
+  match: {declaration: method_declaration, name_child: name, filetype: go}
+  id:
+    from: [pkg, receiver, declared_name]
+    template: '{pkg}.{receiver}.{declared_name}'
+    normalize:
+    - {replace: '\(\s*(?:\w+\s+)?\*?\s*', with: ''}
+    - {replace: '(?:\[[^\]]*\])?\s*\)', with: ''}
+  emits: [{node: {type: go.method}}]
+  confidence: declared
+# type T struct{...} and type T interface{...} are both type_spec; the child type tells them apart.
+- rule: struct
+  reads: file
+  in: [source]
+  match: {declaration: type_spec, name_child: name, filetype: go, where: [{has_child: struct_type}]}
+  id: {from: qualified_name}
+  emits: [{node: {type: go.struct}}]
+  confidence: declared
+- rule: interface
+  reads: file
+  in: [source]
+  match: {declaration: type_spec, name_child: name, filetype: go, where: [{has_child: interface_type}]}
+  id: {from: qualified_name}
+  emits: [{node: {type: go.interface}}]
+  confidence: declared