what is the context for _url and _path in rails - ruby-on-rails

Question

Rails.application.routes.draw do
resources :carts
...
end
Now in controller, I can
cart_url(#cart)
or in view, I can
<%= link_to 'New Cart', new_cart_path %>
In which context are cart_url and new_cart_path defined? (how to see those in rails console)
In rails console, I tried:
irb(main):053:0> ApplicationController.new.rails_postmark_inbound_emails_path
Traceback (most recent call last):
2: from (irb):53
1: from (irb):53:in `rescue in irb_binding'
NoMethodError (undefined method `host' for nil:NilClass)
irb(main):058:0> CartsController.new.carts_url
Traceback (most recent call last):
2: from (irb):58
1: from (irb):58:in `rescue in irb_binding'
NoMethodError (undefined method `host' for nil:NilClass)
irb(main):056:0> CartsController.new_line_item_url
Traceback (most recent call last):
2: from (irb):56
1: from (irb):56:in `rescue in irb_binding'
NoMethodError (undefined method `new_line_item_url' for CartsController:Class)

Answer 1

The context for the route helpers is actually an anomynous module.
# This code was abbreviated for StackOverflow
module ActionDispatch
# A NamedRouteCollection instance is a collection of named routes, and also
# maintains an anonymous module that can be used to install helpers for the
# named routes.
class NamedRouteCollection
include Enumerable
attr_reader :routes, :url_helpers_module, :path_helpers_module
private :routes
def initialize
#routes = {}
#path_helpers = Set.new
#url_helpers = Set.new
#url_helpers_module = Module.new
#path_helpers_module = Module.new
end
def add(name, route)
key = name.to_sym
path_name = :"#{name}_path"
url_name = :"#{name}_url"
if routes.key? key
#path_helpers_module.undef_method path_name
#url_helpers_module.undef_method url_name
end
routes[key] = route
helper = UrlHelper.create(route, route.defaults, name)
define_url_helper #path_helpers_module, path_name, helper, PATH
define_url_helper #url_helpers_module, url_name, helper, UNKNOWN
#path_helpers << path_name
#url_helpers << url_name
end
def get(name)
routes[name.to_sym]
end
def key?(name)
return unless name
routes.key? name.to_sym
end
alias []= add
alias [] get
alias clear clear!
def each(&block)
routes.each(&block)
self
end
def names
routes.keys
end
def length
routes.length
end
# Given a +name+, defines name_path and name_url helpers.
# Used by 'direct', 'resolve', and 'polymorphic' route helpers.
def add_url_helper(name, defaults, &block)
helper = CustomUrlHelper.new(name, defaults, &block)
path_name = :"#{name}_path"
url_name = :"#{name}_url"
#path_helpers_module.module_eval do
redefine_method(path_name) do |*args|
helper.call(self, args, true)
end
end
#url_helpers_module.module_eval do
redefine_method(url_name) do |*args|
helper.call(self, args, false)
end
end
#path_helpers << path_name
#url_helpers << url_name
self
end
end
# ...
end
This module is created before the request is passed to a controller when ActionDispatch reads the route file and builds a routes collection.
And the controller then includes both the url_helpers and path_helpers modules. How this method ends up in the view is a topic upon itself but the gist is that ActionView::Context provides the methods and instance variables of the controller as the context (self) to the templating engine (ERB, Slim, Haml, jBuilder etc).
You can call the route helpers in the console via app. Thats because the console session is actually an integration test (🤯).
irb(main):006:0> app.root_path
=> "/"
irb(main):007:0> app.root_url
=> "http://www.example.com/"
When you do:
irb(main):053:0> ApplicationController.new.rails_postmark_inbound_emails_path
Traceback (most recent call last):
2: from (irb):53
1: from (irb):53:in `rescue in irb_binding'
You get an error since controllers are not meant to be used isolation. That nil:NilClass that host is called on is actually supposed to be a request.
Controllers are Rack applications and they operate by being instanciated and then dispatching a request:
ctrl = PetsController.new
ctrl.dispatch(name, request, response)