Expand cross-repo HTTP-client detection (TS options-object/openapi-fe… (#66)

* Expand cross-repo HTTP-client detection (TS options-object/openapi-fetch, Swift endpoint enums with prefix resolution, Rails draw() scope prefixes) and remove import/shared-symbol false positives

* Resolve Swift request-wrapper/stored-method endpoints from call sites and fix Rails nested singular/plural resource route paths (cache v72)

Author: dejo1307

internal/engine/cache.go

@@ -129,7 +129,20 @@ import (
 // v68: the TypeScript extractor now sets abstract:true on `abstract class`
 // declarations (was previously indistinguishable from a concrete class), so
 // package-metrics abstractness for TS must re-extract to pick up the flag.
-const cacheVersion = "v68"
+// v69: HTTP-client detection expanded — TS options-object/openapi-fetch clients,
+// Swift endpoint-enum (APIEndpoint/TargetType) clients, Rails draw(:pkg) routes now
+// carry their /api/vN scope prefix, and Swift URLSession skips test/fixture sources.
+// v70: Swift endpoint extractor resolves the version prefix — repo-wide default
+// (protocol-extension urlPrefixComponent), single-value/switch-default overrides,
+// and version-constant interpolation — so prefix-less endpoints match backend routes.
+// v71: Swift endpoint extractor resolves stored-method endpoint structs (path/prefix
+// computed, `method` a stored property) by reading the HTTP verb from each
+// instantiation site's `method:` argument, emitting one client route per (path, verb).
+// v72: Swift extractor also resolves request-wrapper endpoints (path supplied at the
+// call site's `urlPathComponent:` arg, verb from `method:`/`httpMethod:` or a type
+// default); Ruby extractor fixes nested Rails resource paths — a singular `resource`
+// gets no `:id`, and children of a plural `resources` nest under `:<singular>_id`.
+const cacheVersion = "v72"
 
 // extractorCache holds per-extractor facts keyed by a content hash of the files
 // the extractor depends on. It is loaded from disk at the start of a snapshot and

internal/extractors/rubyextractor/routes.go

@@ -10,28 +10,59 @@ import (
 )
 
 // extractAllRoutes finds and parses all Rails route files in the repository.
+//
+// Rails commonly splits routes across config/routes/<pkg>.rb files pulled in by
+// draw(:pkg) from config/routes.rb, often inside a scope('/api')/namespace(:vN)
+// block. Parsed standalone, a delegated file loses that prefix, so its routes read
+// as "/devices" instead of "/api/v2/devices" and no longer match a client call. To
+// avoid that, the top-level config/routes.rb is parsed first to learn each
+// delegation's prefix, then each delegated file is parsed seeded with it.
 func extractAllRoutes(repoPath string, files []string) []facts.Fact {
-	var allFacts []facts.Fact
-
 	// Collect route files: config/routes.rb, config/routes/*.rb, packages/*/config/routes/*.rb
 	var routeFiles []string
 	for _, relFile := range files {
-		if !isRubyFile(relFile) {
-			continue
-		}
-		if isRouteFile(relFile) {
+		if isRubyFile(relFile) && isRouteFile(relFile) {
 			routeFiles = append(routeFiles, relFile)
 		}
 	}
 
-	for _, relFile := range routeFiles {
-		absFile := filepath.Join(repoPath, relFile)
-		src, err := os.ReadFile(absFile)
+	readSrc := func(relFile string) ([]byte, bool) {
+		src, err := os.ReadFile(filepath.Join(repoPath, relFile))
 		if err != nil {
 			log.Printf("[ruby-extractor] error reading route file %s: %v", relFile, err)
+			return nil, false
+		}
+		return src, true
+	}
+
+	mainFile := filepath.Join("config", "routes.rb")
+
+	// Pass 1: parse the top-level routes.rb, learning draw(:pkg) -> prefix. Each
+	// draw(:pkg) loads config/routes/<pkg>.rb (Rails convention).
+	var allFacts []facts.Fact
+	drawPrefix := map[string]string{}
+	for _, relFile := range routeFiles {
+		if relFile != mainFile {
 			continue
 		}
-		allFacts = append(allFacts, parseRouteFileAST(src, relFile)...)
+		if src, ok := readSrc(relFile); ok {
+			ff, draws := parseRouteFile(src, relFile, "")
+			allFacts = append(allFacts, ff...)
+			for pkg, prefix := range draws {
+				drawPrefix[filepath.Join("config", "routes", pkg+".rb")] = prefix
+			}
+		}
+	}
+
+	// Pass 2: parse the remaining route files, seeding any prefix learned in pass 1.
+	for _, relFile := range routeFiles {
+		if relFile == mainFile {
+			continue
+		}
+		if src, ok := readSrc(relFile); ok {
+			ff, _ := parseRouteFile(src, relFile, drawPrefix[relFile])
+			allFacts = append(allFacts, ff...)
+		}
 	}
 
 	return allFacts
@@ -61,6 +92,10 @@ func isRouteFile(relFile string) bool {
 type routeScope struct {
 	pathPrefix string
 	module     string
+	// memberParam is the parent member path parameter (`:<singular>_id`) that nested
+	// resources declared inside a *plural* `resources` block must nest under; empty for
+	// namespace/scope/singular-resource scopes, which add no member id to their children.
+	memberParam string
 }
 
 // buildPrefix constructs the current URL prefix from the scope stack.
@@ -103,6 +138,28 @@ func restfulActions(only, except map[string]bool) []restAction {
 	return all
 }
 
+// restfulActionsSingular returns the REST actions for a singular `resource`
+// declaration. A singular resource has no index and no `:id` member segment — every
+// action acts on the single resource at its base path.
+func restfulActionsSingular(only, except map[string]bool) []restAction {
+	all := []restAction{
+		{name: "create", method: "POST", suffix: ""},
+		{name: "new", method: "GET", suffix: "/new"},
+		{name: "show", method: "GET", suffix: ""},
+		{name: "update", method: "PATCH", suffix: ""},
+		{name: "edit", method: "GET", suffix: "/edit"},
+		{name: "destroy", method: "DELETE", suffix: ""},
+	}
+
+	if len(only) > 0 {
+		return filterActions(all, only, true)
+	}
+	if len(except) > 0 {
+		return filterActions(all, except, false)
+	}
+	return all
+}
+
 // filterActions returns actions filtered by an allow or deny list.
 func filterActions(all []restAction, names map[string]bool, isAllow bool) []restAction {
 	var result []restAction

internal/extractors/rubyextractor/routes_ast.go

@@ -13,24 +13,40 @@ import (
 // facts. Block boundaries come from the grammar (do_block) rather than counting
 // `do`/`end`, so nested namespaces/resources/scopes are tracked precisely.
 func parseRouteFileAST(src []byte, relFile string) []facts.Fact {
+	ff, _ := parseRouteFile(src, relFile, "")
+	return ff
+}
+
+// parseRouteFile parses a Rails route file, seeding the scope stack with
+// initialPrefix (the URL prefix a parent routes.rb delegated this file under via
+// draw(:pkg)), and additionally returns the draw(:pkg) -> prefix map discovered in
+// this file, so the caller can inline each delegated file under its real scope.
+func parseRouteFile(src []byte, relFile, initialPrefix string) ([]facts.Fact, map[string]string) {
 	parser := sitter.NewParser()
 	defer parser.Close()
 	if err := parser.SetLanguage(sitter.NewLanguage(ruby.Language())); err != nil {
-		return nil
+		return nil, nil
 	}
 	tree := parser.Parse(src, nil)
 	defer tree.Close()
 
-	rw := &routeWalker{src: src, relFile: relFile, dir: filepath.Dir(relFile)}
-	rw.walk(tree.RootNode(), nil)
-	return rw.out
+	var stack []routeScope
+	if initialPrefix != "" {
+		stack = []routeScope{{pathPrefix: initialPrefix}}
+	}
+	rw := &routeWalker{src: src, relFile: relFile, dir: filepath.Dir(relFile), draws: map[string]string{}}
+	rw.walk(tree.RootNode(), stack)
+	return rw.out, rw.draws
 }
 
 type routeWalker struct {
 	src     []byte
 	relFile string
 	dir     string
 	out     []facts.Fact
+	// draws maps each draw(:pkg) delegation found in this file to the URL prefix it
+	// is scoped under, so the caller can parse config/routes/<pkg>.rb with it.
+	draws map[string]string
 }
 
 // walk iterates the statements of a program / body_statement, dispatching each
@@ -103,8 +119,25 @@ func (rw *routeWalker) handleCall(call *sitter.Node, stack []routeScope) {
 		}
 		only := pairSymbols(args, "only", rw.src)
 		except := pairSymbols(args, "except", rw.src)
-		resourcePath := prefix + "/" + name
-		for _, a := range restfulActions(only, except) {
+		singular := method == "resource"
+
+		// A resource nested inside a *plural* `resources` block nests under the parent
+		// member (`/widgets/:widget_id/...`); the parent supplies that param via the
+		// enclosing scope's memberParam.
+		parentMember := ""
+		if len(stack) > 0 {
+			if p := stack[len(stack)-1].memberParam; p != "" {
+				parentMember = "/:" + p
+			}
+		}
+		segment := parentMember + "/" + name
+		resourcePath := prefix + segment
+
+		actions := restfulActions(only, except)
+		if singular {
+			actions = restfulActionsSingular(only, except)
+		}
+		for _, a := range actions {
 			rw.emit(resourcePath+a.suffix, line(call), map[string]any{
 				"method":    a.method,
 				"framework": "rails",
@@ -114,7 +147,12 @@ func (rw *routeWalker) handleCall(call *sitter.Node, stack []routeScope) {
 			})
 		}
 		if body != nil {
-			rw.walk(body, append(stack, routeScope{pathPrefix: "/" + name}))
+			// A plural resource exposes a member id to its children; a singular one does not.
+			childMember := ""
+			if !singular {
+				childMember = singularize(name) + "_id"
+			}
+			rw.walk(body, append(stack, routeScope{pathPrefix: segment, memberParam: childMember}))
 		}
 
 	case "namespace":
@@ -156,6 +194,13 @@ func (rw *routeWalker) handleCall(call *sitter.Node, stack []routeScope) {
 			return
 		}
 		if pkg := firstSymbolArg(args, rw.src); pkg != "" {
+			// Record the delegation so the caller can parse config/routes/<pkg>.rb
+			// seeded with this prefix, giving its routes their real /api/vN scope.
+			if rw.draws != nil {
+				rw.draws[pkg] = prefix
+			}
+			// A DRAW placeholder route is still emitted (it backs route helpers); the
+			// linker treats method "DRAW" as inert, so it never matches or is flagged.
 			rw.out = append(rw.out, facts.Fact{
 				Kind: facts.KindRoute,
 				Name: prefix + "/" + pkg,

internal/extractors/rubyextractor/ruby_test.go

@@ -774,6 +774,148 @@ end
 	}
 }
 
+// routeMethods indexes route facts as name -> set of HTTP methods (a singular
+// resource emits several verbs on one path, so a plain name->fact map would drop them).
+func routeMethods(result []facts.Fact) map[string]map[string]bool {
+	out := map[string]map[string]bool{}
+	for _, f := range result {
+		if f.Kind != facts.KindRoute {
+			continue
+		}
+		if out[f.Name] == nil {
+			out[f.Name] = map[string]bool{}
+		}
+		if m, _ := f.Props["method"].(string); m != "" {
+			out[f.Name][m] = true
+		}
+	}
+	return out
+}
+
+// TestRoutes_NestedSingularResource: a singular `resource` nested in a plural
+// `resources` nests under the parent member (`/:<singular>_id`) and has no id of its
+// own — show/create/destroy all map to the base path.
+func TestRoutes_NestedSingularResource(t *testing.T) {
+	src := `Rails.application.routes.draw do
+  resources :widgets, only: [:show] do
+    resource :follow, only: [:show, :create, :destroy]
+  end
+end
+`
+	routes := routeMethods(parseRouteFileAST([]byte(src), "config/routes.rb"))
+
+	if _, ok := routes["/widgets/:id"]; !ok {
+		t.Errorf("missing parent route /widgets/:id; got %v", routes)
+	}
+	follow := routes["/widgets/:widget_id/follow"]
+	for _, m := range []string{"GET", "POST", "DELETE"} {
+		if !follow[m] {
+			t.Errorf("follow: missing %s among %v (route /widgets/:widget_id/follow)", m, follow)
+		}
+	}
+	// The old buggy shapes must NOT appear.
+	for _, absent := range []string{"/widgets/follow", "/widgets/follow/:id", "/widgets/:widget_id/follow/:id"} {
+		if _, ok := routes[absent]; ok {
+			t.Errorf("route %q should not be produced (nested singular resource)", absent)
+		}
+	}
+}
+
+// TestRoutes_NestedPluralResources: a plural `resources` nested in a plural
+// `resources` nests under the parent member id.
+func TestRoutes_NestedPluralResources(t *testing.T) {
+	src := `Rails.application.routes.draw do
+  resources :widgets do
+    resources :items, only: [:index, :show]
+  end
+end
+`
+	routes := routeMethods(parseRouteFileAST([]byte(src), "config/routes.rb"))
+	for _, want := range []string{"/widgets/:widget_id/items", "/widgets/:widget_id/items/:id"} {
+		if _, ok := routes[want]; !ok {
+			t.Errorf("missing route %q; got %v", want, routes)
+		}
+	}
+	if _, ok := routes["/widgets/items"]; ok {
+		t.Errorf("nested plural resources must nest under the parent member id")
+	}
+}
+
+// TestRoutes_TopLevelSingularResource: a top-level singular `resource` has no id.
+func TestRoutes_TopLevelSingularResource(t *testing.T) {
+	src := `Rails.application.routes.draw do
+  resource :session, only: [:show, :create, :destroy]
+end
+`
+	routes := routeMethods(parseRouteFileAST([]byte(src), "config/routes.rb"))
+	session := routes["/session"]
+	for _, m := range []string{"GET", "POST", "DELETE"} {
+		if !session[m] {
+			t.Errorf("session: missing %s among %v", m, session)
+		}
+	}
+	if _, ok := routes["/session/:id"]; ok {
+		t.Errorf("singular resource must not have an :id member path")
+	}
+}
+
+// TestRoutes_DrawPrefixSeeding verifies that (1) a top-level routes.rb reports the
+// prefix each draw(:pkg) is scoped under, and (2) parsing a delegated file seeded
+// with that prefix yields fully-qualified routes that a client call can match.
+func TestRoutes_DrawPrefixSeeding(t *testing.T) {
+	main := `Rails.application.routes.draw do
+  scope '/api', defaults: { format: 'json' } do
+    namespace(:core) do
+      namespace(:v3) do
+        draw(:api_core_v3_routes)
+      end
+    end
+    namespace(:v2) do
+      draw(:api_v2_routes)
+    end
+  end
+  draw(:admin_routes)
+end
+`
+	_, draws := parseRouteFile([]byte(main), "config/routes.rb", "")
+	if draws["api_core_v3_routes"] != "/api/core/v3" {
+		t.Errorf("api_core_v3_routes prefix = %q, want /api/core/v3", draws["api_core_v3_routes"])
+	}
+	if draws["api_v2_routes"] != "/api/v2" {
+		t.Errorf("api_v2_routes prefix = %q, want /api/v2", draws["api_v2_routes"])
+	}
+	if draws["admin_routes"] != "" {
+		t.Errorf("admin_routes prefix = %q, want empty", draws["admin_routes"])
+	}
+
+	// A delegated file parsed with the learned prefix produces qualified routes,
+	// including single-segment collections lifted above the 2-segment match floor.
+	sub := `resources :devices, only: [:destroy]
+resources :interactions, only: [:index]
+namespace :event do
+  resources :posts, only: [:create]
+end
+`
+	ff, _ := parseRouteFile([]byte(sub), "config/routes/api_v2_routes.rb", draws["api_v2_routes"])
+	names := map[string]bool{}
+	for _, f := range ff {
+		names[f.Name] = true
+	}
+	for _, want := range []string{"/api/v2/devices/:id", "/api/v2/interactions", "/api/v2/event/posts"} {
+		if !names[want] {
+			t.Errorf("missing seeded route %q; got %v", want, keys2(names))
+		}
+	}
+}
+
+func keys2(m map[string]bool) []string {
+	out := make([]string, 0, len(m))
+	for k := range m {
+		out = append(out, k)
+	}
+	return out
+}
+
 func TestRoutes_VerbWithHandler(t *testing.T) {
 	src := `Rails.application.routes.draw do
   root to: "home#index"