# Ruby dans Maguyva : des graphes de code pour Rails et les apps Ruby

Canonical source: https://maguyva.ai/fr/languages/ruby

License: text under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/); code samples under [MIT-0](https://opensource.org/license/mit-0); the Maguyva name, logos, brand assets and other code are not covered. Details: [maguyva.ai/license](https://maguyva.ai/license).

Maguyva prend en charge Ruby avec AST, symboles et graphe, pour que les agents IA suivent classes, modules, méthodes singleton et instanciations dans Rails et Ruby.

## Aperçu du support

- Palier: Prise en charge de l’AST et des symboles
- Programmation
- Extensions: .gemfile, .gemspec, .rake, .rakefile, .rb, .rbw
- Analyse AST réelle pour une recherche consciente de la syntaxe et un contexte structurel.
- Les symboles nommés alimentent la recherche sémantique et le référencement croisé. La navigation par graphe est disponible lorsque l’extraction de relations est activée.
- Ce langage fournit des symboles et des relations à la recherche tenant compte du graphe ; les types d’arêtes pris en charge varient selon ses constructions natives.
- L’analyse AST et l’extraction de symboles sont toutes deux disponibles.

## Idéal pour

- Les monolithes Rails où modèles, objets de service, jobs et concerns s'appellent à travers de nombreux répertoires.
- Les gems et services Ruby aux espaces de noms de modules profonds et aux classes de base partagées.
- Les équipes qui veulent circonscrire un changement avec un agent IA avant de toucher un modèle ou un service dont dépend la moitié de l'application.

## Workflows d'agent

- Trouver tous les appelants d'un objet de service ou d'une méthode de modèle avant d'en changer le comportement.
- Retracer où une classe est instanciée avec `.new` et quelles méthodes s'exécutent ensuite.
- Cartographier les classes qui héritent d'une classe de base ou incluent un module avant un refactoring.

## Pourquoi les dépôts Ruby posent problème aux outils d'IA superficiels

Ruby s'appuie fortement sur les conventions et la métaprogrammation. Des méthodes sont générées par `attr_accessor`, des classes sont rouvertes dans d'autres fichiers, et les espaces de noms imbriquent plusieurs niveaux de modules. La surface lisible cache la méthode qu'un appel atteint réellement, et une recherche textuelle brute renvoie chaque `call` et chaque `perform` de l'application.

Maguyva donne à l'agent classes, modules, méthodes et appelants sous forme de structure, pour qu'il suive un changement à travers l'application au lieu de deviner.

## Ce que Maguyva extrait en Ruby

Maguyva couvre les fichiers `.rb`, `.rbw`, `.rake` et `.gemspec`, ainsi que `Gemfile` et `Rakefile`. Les méthodes d'instance et les méthodes singleton (`def self.call`) sont extraites, les méthodes singleton étant marquées comme statiques. Les déclarations `attr_reader`, `attr_writer` et `attr_accessor` comptent comme méthodes d'accès, et les symboles sont qualifiés par leur espace de noms de module et de classe.

`ClassName.new` et `Namespace::ClassName.new` comptent comme instanciation, et le typage des receveurs suit les affectations locales et les `@instance_variables`, de sorte qu'un appel sur un objet affecté peut se résoudre vers sa classe. Le graphe enregistre aussi l'héritage, l'inclusion de modules, les surcharges, les arêtes `raise` et `rescue`, ainsi que les lectures et écritures.

Les appels de métaprogrammation (`define_method`, `send`, `method_missing`, `class_eval` et similaires), les helpers de type `T::` de Sorbet et les appels énumérables courants (`each`, `collect`, `reject` et similaires) sont filtrés des relations pour faire ressortir le code applicatif.

## Exemples de prompts pour agents

- « Qui appelle `Billing::ChargeCustomer.call`, et depuis quels jobs et contrôleurs ? » (`find_symbol`, puis `dependency_search` en incoming)
- « Quels modèles héritent de `ApplicationRecord` et incluent `Auditable` ? » (`dependency_search`)
- « Retrace ce qui se passe après qu'une commande est marquée comme payée. » (`get_task_context`)

## Limites connues

- En Ruby, `require` et `load` sont des appels de méthode ordinaires ; le préréglage `imports` de `structural_search` ne sélectionne donc rien. Utilisez `text_pattern_search` pour les lister.
- Les méthodes créées à l'exécution avec `define_method` ou traitées par `method_missing` ne sont pas extraites comme symboles, et ces appels sont filtrés comme bruit de métaprogrammation.
- Ruby n'a pas de syntaxe de décorateur ; les relations de décorateur sont donc marquées comme non applicables.

## Étapes suivantes

Connectez un dépôt avec le [démarrage rapide](/fr/docs/quickstart), puis consultez la matrice de prise en charge sur la [page de compatibilité](/fr/docs/compatibility). Pour d'autres dépôts en langages dynamiques, comparez avec le [guide Python](/fr/languages/python).

## Détails du moteur

- La prise en charge de Ruby couvre `.rb`, `.rbw`, `.rake`, `.gemspec`, `Gemfile` et `Rakefile`. Les méthodes singleton sont marquées statiques, et les déclarations `attr_*` comptent comme méthodes d'accès.
- `ClassName.new` compte comme instanciation, et le typage des receveurs suit les affectations locales et les variables d'instance.
- Les appels de métaprogrammation comme `define_method` et `send`, les helpers `T::` de Sorbet et les appels énumérables courants sont filtrés des relations.

## Points d'entrée MCP utiles

- `find_symbol`: Utilisez-le pour une classe, un module ou une méthode avec espace de noms, comme `Billing::ChargeCustomer.call`.
- `dependency_search`: Utilisez la traversée incoming sur un modèle ou un objet de service pour voir appelants et sous-classes avant un changement.
- `text_pattern_search`: Utilisez-le pour les chemins `require`, les chaînes de routes et les méthodes définies dynamiquement que le graphe ne voit pas.