Gli helper di routing Rails (ovvero mymodel_path (modello)) possono essere utilizzati nei modelli?

Supponiamo che io abbia un modello Rails chiamato Thing. La cosa ha un attributo url che può essere facoltativamente impostato su un URL da qualche parte su Internet. Nel codice vista, ho bisogno di una logica che procede come segue:

<% if thing.url.blank? %>
<%= link_to('Text', thing_path(thing)) %>
<% else %>
<%= link_to('Text', thing.url) %>
<% end %>

Questa logica condizionale nella vista è brutta. Naturalmente, potrei creare una funzione di supporto, che cambierebbe la vista in questo:

<%= thing_link('Text', thing) %>

Questo risolve il problema della verbosità, ma preferirei davvero avere la funzionalità nel modello stesso. In tal caso, il codice vista sarebbe:

<%= link_to('Text', thing.link) %>

Ciò, ovviamente, richiederebbe un metodo di collegamento sul modello. Ecco cosa dovrebbe contenere:

def link
  (self.url.blank?) ? thing_path(self) : self.url
end

Al punto della domanda, thing_path () è un metodo indefinito all'interno del codice modello. Suppongo che sia possibile "inserire" alcuni metodi di supporto nel modello, ma come? E c'è una vera ragione per cui il routing funziona solo sul controller e visualizza i livelli dell'app? Mi vengono in mente molti casi in cui potrebbe essere necessario che il codice modello gestisca gli URL (integrazione con sistemi esterni, ecc.).

In Rails 3, 4 e 5 puoi usare:

Rails.application.routes.url_helpers

per esempio

Rails.application.routes.url_helpers.posts_path
Rails.application.routes.url_helpers.posts_url(:host => "example.com")

Ho trovato la risposta su come farlo da solo. All'interno del codice modello, basta inserire:

Per binari <= 2:

include ActionController::UrlWriter

Per Rails 3:

include Rails.application.routes.url_helpers

In questo modo magicamente viene thing_path(self)restituito l'URL per la cosa corrente o other_model_path(self.association_to_other_model)restituito un altro URL.

Potresti anche trovare il seguente approccio più pulito di includere ogni metodo:

class Thing
  delegate :url_helpers, to: 'Rails.application.routes' 

  def url
    url_helpers.thing_path(self)
  end
end

Qualsiasi logica relativa a ciò che viene visualizzato nella vista deve essere delegata a un metodo di supporto, poiché i metodi nel modello sono strettamente per la gestione dei dati.

Ecco cosa potresti fare:

# In the helper...

def link_to_thing(text, thing)
  (thing.url?) ? link_to(text, thing_path(thing)) : link_to(text, thing.url)
end

# In the view...

<%= link_to_thing("text", @thing) %>

Mi piace molto seguire una soluzione pulita.

class Router
  include Rails.application.routes.url_helpers

  def self.default_url_options
    ActionMailer::Base.default_url_options
  end
end

router = Router.new
router.posts_url  # http://localhost:3000/posts
router.posts_path # /posts

È da http://hawkins.io/2012/03/generating_urls_whenever_and_wherever_you_want/

Mentre ci potrebbe essere un modo in cui tenderei a tenere quel tipo di logica fuori dal Modello. Sono d'accordo che non dovresti metterlo in vista ( mantienilo magro ) ma a meno che il modello non restituisca un url come pezzo di dati al controller, le cose di routing dovrebbero essere nel controller.

(Modifica: dimentica la mia precedente chiacchiera ...)

Ok, ci potrebbero essere situazioni in cui potresti andare sul modello o su qualche altro URL ... Ma non penso davvero che questo appartenga al modello, la vista (o forse il modello) sembra più appropriata.

Per quanto riguarda le rotte, per quanto ne so le rotte sono per le azioni nei controller (che di solito "magicamente" usa una vista), non direttamente alle viste. Il controller dovrebbe gestire tutte le richieste, la vista dovrebbe presentare i risultati e il modello dovrebbe gestire i dati e servirli alla vista o al controller. Ho sentito molte persone qui parlare di rotte verso modelli (al punto che sto quasi iniziando a crederci), ma a quanto ho capito: le rotte vanno ai controller. Naturalmente molti controller sono controller per un modello e vengono spesso chiamati<modelname>sController (ad es. "UsersController" è il controller del modello "User").

Se ti ritrovi a scrivere cattive quantità di logica in una vista, prova a spostare la logica in un posto più appropriato; la logica di richiesta e di comunicazione interna appartiene probabilmente al controller, la logica relativa ai dati potrebbe essere inserita nel modello (ma non la logica di visualizzazione, che include tag di collegamento ecc.) e la logica che è puramente correlata alla visualizzazione verrebbe inserita in un helper.