class Tapioca::Dsl::Compilers::UrlHelpers

~~~
end
include GeneratedUrlHelpersModule
include GeneratedPathHelpersModule
class Post
# typed: true
# post.rbi
~~~rbi
~~~
end
def new_index_url(*args); end
sig { params(args: T.untyped).returns(String) }
def index_url(*args); end
sig { params(args: T.untyped).returns(String) }
def edit_index_url(*args); end
sig { params(args: T.untyped).returns(String) }
include ActionDispatch::Routing::UrlFor
include ActionDispatch::Routing::PolymorphicRoutes
module GeneratedUrlHelpersModule
# typed: true
# generated_url_helpers_module.rbi
~~~rbi
~~~
end
def new_index_path(*args); end
sig { params(args: T.untyped).returns(String) }
def index_path(*args); end
sig { params(args: T.untyped).returns(String) }
def edit_index_path(*args); end
sig { params(args: T.untyped).returns(String) }
include ActionDispatch::Routing::UrlFor
include ActionDispatch::Routing::PolymorphicRoutes
module GeneratedPathHelpersModule
# typed: true
# generated_path_helpers_module.rbi
~~~rbi
this compiler will produce the following RBI files:
~~~
end
T.unsafe(self).include Rails.application.routes.url_helpers
# static type checking will work as expected.
# compiler will generate the proper RBI files for the include,
# at runtime but Sorbet won’t see the include. However, since this
# module being included. This allows the ‘include` to happen properly
# Use `T.unsafe` so that Sorbet does not complain about a dynamic
class Post
app/models/post.rb
~~~rb
~~~
end
end
resource :index
routes.draw do
class Application < Rails::Application
# config/application.rb
~~~rb
For example, with the following setup:<br><br>(api.rubyonrails.org/v5.1.7/classes/ActionDispatch/Routing/UrlFor.html#module-ActionDispatch::Routing::UrlFor-label-URL+generation+for+named+routes).
`Tapioca::Dsl::Compilers::UrlHelpers` generates RBI files for classes that include or extend

def create_mixins_for(mod, helper_module) 

def create_mixins_for(mod, helper_module)
  include_helper = constant.ancestors.include?(helper_module) || NON_DISCOVERABLE_INCLUDERS.include?(constant)
  extend_helper = constant.singleton_class.ancestors.include?(helper_module)
  mod.create_include(T.must(helper_module.name)) if include_helper
  mod.create_extend(T.must(helper_module.name)) if extend_helper
end

def decorate 

def decorate
  case constant
  when GeneratedPathHelpersModule.singleton_class, GeneratedUrlHelpersModule.singleton_class
    generate_module_for(root, constant)
  else
    root.create_path(constant) do |mod|
      create_mixins_for(mod, GeneratedUrlHelpersModule)
      create_mixins_for(mod, GeneratedPathHelpersModule)
    end
  end
end

def gather_constants 

def gather_constants
  return [] unless defined?(Rails.application) && Rails.application
  Object.const_set(:GeneratedUrlHelpersModule, Rails.application.routes.named_routes.url_helpers_module)
  Object.const_set(:GeneratedPathHelpersModule, Rails.application.routes.named_routes.path_helpers_module)
  constants = all_modules.select do |mod|
    next unless name_of(mod)
    includes_helper?(mod, GeneratedUrlHelpersModule) ||
      includes_helper?(mod, GeneratedPathHelpersModule) ||
      includes_helper?(mod.singleton_class, GeneratedUrlHelpersModule) ||
      includes_helper?(mod.singleton_class, GeneratedPathHelpersModule)
  end
  constants.concat(NON_DISCOVERABLE_INCLUDERS)
end

def gather_non_discoverable_includers 

def gather_non_discoverable_includers
  [].tap do |includers|
    if defined?(ActionController::TemplateAssertions) && defined?(ActionDispatch::IntegrationTest)
      includers << ActionDispatch::IntegrationTest
    end
    if defined?(ActionView::Helpers)
      includers << ActionView::Helpers
    end
  end.freeze
end

def generate_module_for(root, constant) 

def generate_module_for(root, constant)
  root.create_module(T.must(constant.name)) do |mod|
    mod.create_include("::ActionDispatch::Routing::UrlFor")
    mod.create_include("::ActionDispatch::Routing::PolymorphicRoutes")
    constant.instance_methods(false).each do |method|
      mod.create_method(
        method.to_s,
        parameters: [create_rest_param("args", type: "T.untyped")],
        return_type: "String",
      )
    end
  end
end

def includes_helper?(mod, helper) 

def includes_helper?(mod, helper)
lass_ancestors = []
ss === mod
rclass = superclass_of(mod)
rclass_ancestors = ancestors_of(superclass) if superclass
ors = Set.new.compare_by_identity.merge(ancestors_of(mod)).subtract(superclass_ancestors)
ors.any? { |ancestor| helper == ancestor }