fix up page finder

Author: kulturbande

…services/alchemy/wildcard_url_matcher.rb app/services/alchemy/page_finder.rbapp/services/alchemy/wildcard_url_matcher.rb renamed to app/services/alchemy/page_finder.rb app/services/alchemy/wildcard_url_matcher.rb renamed to app/services/alchemy/page_finder.rb

@@ -1,30 +1,37 @@
 # frozen_string_literal: true
 
 module Alchemy
-  class WildcardUrlMatcher
-    attr_reader :page, :params
+  class PageFinder
+    attr_reader :parent_page, :params
 
-    def initialize(parent_page = Current.language.root_page)
+    def initialize(parent_page = Current.language.root_page, params: ActionController::Parameters.new)
       @parent_page = parent_page
-      @params = ActionController::Parameters.new
-      @page = nil
+      @params = params
     end
 
     def call(urlname)
-      @page = find_page(urlname)
-      self
+      return if parent_page.nil? || urlname.blank?
+
+      find_by_urlname(urlname) || find_by_wildcard(urlname)
     end
 
     private
 
+    # Finds a page by exact urlname match within the current language.
+    #
+    # @return [Alchemy::Page]
+    def find_by_urlname(urlname)
+      parent_page.children.contentpages.find_by(urlname: urlname)
+    end
+
     # Walks the page tree level by level, matching URL segments against page slugs or wildcard URLs.
     #
-    # @return [Alchemy::Page, nil] the matched page or nil if no match
-    def find_page(urlname)
-      return if urlname.blank? || @parent_page.nil? || wildcard_layout_names.empty?
+    # @return [Alchemy::Page] the matched page or nil if no match
+    def find_by_wildcard(urlname)
+      return if wildcard_layout_names.empty?
 
       segments = urlname.split("/")
-      current_parent = @parent_page
+      current_parent = parent_page
       path_prefix = nil
       page = nil
 

…ces/alchemy/wildcard_url_matcher_spec.rb spec/services/alchemy/page_finder_spec.rbspec/services/alchemy/wildcard_url_matcher_spec.rb renamed to spec/services/alchemy/page_finder_spec.rb spec/services/alchemy/wildcard_url_matcher_spec.rb renamed to spec/services/alchemy/page_finder_spec.rb

@@ -3,7 +3,7 @@
 require "rails_helper"
 
 module Alchemy
-  RSpec.describe WildcardUrlMatcher do
+  RSpec.describe PageFinder do
     let(:language) { create(:alchemy_language) }
     let!(:language_root) do
       create(:alchemy_page, :language_root, language: language)
@@ -48,70 +48,77 @@ def create_page(name:, layout: "standard", parent: language_root)
     let!(:users_page) { create_page(name: "Users") }
     let!(:user_profile_page) { create_page(name: "User Profile", layout: "user_profile", parent: users_page) }
 
+    let(:params) { ActionController::Parameters.new }
+
     it "defaults to Current.language.root_page" do
-      matcher = described_class.new.call("products/123")
-      expect(matcher.page).to eq(product_detail_page)
-      expect(matcher.params[:id]).to eq("123")
+      page = described_class.new(params: params).call("products/123")
+      expect(page).to eq(product_detail_page)
+      expect(params[:id]).to eq("123")
+    end
+
+    it "finds a page by exact urlname" do
+      page = described_class.new(params: params).call("products")
+      expect(page).to eq(products_page)
     end
 
     it "returns nil when the parent page is nil" do
-      expect(described_class.new(nil).call("products/123").page).to be_nil
+      expect(described_class.new(nil, params: params).call("products/123")).to be_nil
     end
 
     it "returns nil for a blank path" do
-      expect(described_class.new(language_root).call("").page).to be_nil
+      expect(described_class.new(language_root, params: params).call("")).to be_nil
     end
 
     it "returns nil for a path with no matching prefix" do
-      expect(described_class.new(language_root).call("other/123").page).to be_nil
+      expect(described_class.new(language_root, params: params).call("other/123")).to be_nil
     end
 
     context "single-segment pattern with integer constraint" do
       it "matches /products/123" do
-        matcher = described_class.new(language_root).call("products/123")
-        expect(matcher.page).to eq(product_detail_page)
-        expect(matcher.params[:id]).to eq("123")
+        page = described_class.new(language_root, params: params).call("products/123")
+        expect(page).to eq(product_detail_page)
+        expect(params[:id]).to eq("123")
       end
 
       it "rejects non-integer and falls through to unconstrained sibling" do
-        matcher = described_class.new(language_root).call("products/some-slug")
-        expect(matcher.page).to eq(product_by_slug_page)
-        expect(matcher.params[:slug]).to eq("some-slug")
+        page = described_class.new(language_root, params: params).call("products/some-slug")
+        expect(page).to eq(product_by_slug_page)
+        expect(params[:slug]).to eq("some-slug")
       end
     end
 
     context "multi-segment pattern" do
       it "matches /blog/2024/my-post and extracts both params" do
-        matcher = described_class.new(language_root).call("blog/2024/my-post")
-        expect(matcher.page).to eq(blog_post_page)
-        expect(matcher.params[:year]).to eq("2024")
-        expect(matcher.params[:slug]).to eq("my-post")
+        page = described_class.new(language_root, params: params).call("blog/2024/my-post")
+        expect(page).to eq(blog_post_page)
+        expect(params[:year]).to eq("2024")
+        expect(params[:slug]).to eq("my-post")
       end
 
       it "does not match with wrong segment count" do
-        expect(described_class.new(language_root).call("blog/2024").page).to be_nil
+        expect(described_class.new(language_root, params: params).call("blog/2024")).to be_nil
       end
     end
 
     context "pattern with static segments" do
       let(:uuid) { "550e8400-e29b-41d4-a716-446655440000" }
 
       it "matches /users/:uuid/profile" do
-        matcher = described_class.new(language_root).call("users/#{uuid}/profile")
-        expect(matcher.page).to eq(user_profile_page)
-        expect(matcher.params[:uuid]).to eq(uuid)
+        page = described_class.new(language_root, params: params).call("users/#{uuid}/profile")
+        expect(page).to eq(user_profile_page)
+        expect(params[:uuid]).to eq(uuid)
       end
 
       it "does not match without the trailing static segment" do
-        expect(described_class.new(language_root).call("users/#{uuid}").page).to be_nil
+        expect(described_class.new(language_root, params: params).call("users/#{uuid}")).to be_nil
       end
     end
 
     context "hierarchical patterns (grandchild under pattern page)" do
       it "matches /products/42/comments through the pattern parent" do
-        matcher = described_class.new(language_root).call("products/42/comments")
-        expect(matcher.page).to eq(comments_page)
-        expect(matcher.params[:id]).to eq("42")
+        page = described_class.new(language_root, params: params).call("products/42/comments")
+        expect(page).to eq(comments_page)
+        expect(params[:id]).to eq("42")
       end
     end
 
@@ -122,10 +129,10 @@ def create_page(name:, layout: "standard", parent: language_root)
       let!(:child_of_single) { create_page(name: "My Post", parent: single_segment_page) }
 
       it "matches the first pattern sibling even when the other could also match via its child" do
-        matcher = described_class.new(language_root).call("shared/2024/my-post")
-        expect(matcher.page).to eq(multi_segment_page)
-        expect(matcher.params[:year]).to eq("2024")
-        expect(matcher.params[:slug]).to eq("my-post")
+        page = described_class.new(language_root, params: params).call("shared/2024/my-post")
+        expect(page).to eq(multi_segment_page)
+        expect(params[:year]).to eq("2024")
+        expect(params[:slug]).to eq("my-post")
       end
     end
 
@@ -134,13 +141,13 @@ def create_page(name:, layout: "standard", parent: language_root)
       let!(:sku_page) { create_page(name: "SKU Lookup", layout: "product_by_sku", parent: warehouse_page) }
 
       it "matches when the value satisfies the regex" do
-        matcher = described_class.new(language_root).call("warehouse/AB-1234")
-        expect(matcher.page).to eq(sku_page)
-        expect(matcher.params[:sku]).to eq("AB-1234")
+        page = described_class.new(language_root, params: params).call("warehouse/AB-1234")
+        expect(page).to eq(sku_page)
+        expect(params[:sku]).to eq("AB-1234")
       end
 
       it "does not match when the value violates the regex" do
-        expect(described_class.new(language_root).call("warehouse/invalid").page).to be_nil
+        expect(described_class.new(language_root, params: params).call("warehouse/invalid")).to be_nil
       end
     end
   end