Como usar o método auxiliar “number_to_currency” no modelo em vez de na visualização?

Eu gostaria de usar o to_dollarmétodo em meu modelo assim:

module JobsHelper      
  def to_dollar(amount)
    if amount < 0
      number_to_currency(amount.abs, :precision => 0, :format => "-%u%n")
    else
      number_to_currency(amount, :precision => 0)
    end
  end      
end

class Job < ActiveRecord::Base
  include JobsHelper
  def details
    return "Only " + to_dollar(part_amount_received) + 
           " out of " + to_dollar(price) + " received."
  end
end

Infelizmente, o number_to_currencymétodo não é reconhecido aqui:

método indefinido `number_to_currency 'para # <Job: 0x311eb00>

Alguma ideia de como fazer funcionar?

Não está disponível porque seu uso em um modelo (normalmente) viola o MVC (e parece que sim no seu caso). Você está pegando dados e manipulando-os para apresentação. Isso, por definição, pertence à visão, não ao modelo.

Aqui estão algumas soluções:

• Use um apresentador ou objeto de modelo de exibição para mediar entre o modelo e a exibição. Isso quase definitivamente requer mais trabalho inicial do que outras soluções, mas quase sempre é um design melhor. O uso de helpers em um apresentador / modelo de visualização não viola o MVC, pois eles residem na camada de visualização, substituindo auxiliares Rails personalizados tradicionais e visualizações preenchidas com lógica.

• Explicitamente include ActionView::Helpers::NumberHelperem JobsHelpervez de depender do Rails para carregá-lo magicamente para você. Isso ainda não é ótimo, pois você não deve acessar um auxiliar de um modelo.

• Violar MVC e SRP . Veja a resposta de fguillen para saber como fazer isso. Não vou repetir aqui porque não concordo com isso. Ainda mais, eu discordo em poluir seu modelo com métodos de apresentação como na resposta de Sam .

Se você pensa “mas eu realmente preciso disso para escrever meus to_csv& to_pdfmétodos em meu modelo!”, Então toda a sua premissa está errada - afinal, você não tem um to_htmlmétodo, não é? E ainda assim, seu objeto é frequentemente renderizado como HTML. Considere a criação de uma nova classe para gerar sua saída em vez de fazer seu modelo de dados saber o que é um CSV ( porque não deveria ).

Quanto ao uso de auxiliares para erros de validação de ActiveModel no modelo, bem, sinto muito, mas ActiveModel / Rails nos ferrou, forçando mensagens de erro a serem realizadas na camada de dados, em vez de retornar a ideia semântica de um erro a ser percebi mais tarde - suspiro . Você pode contornar isso, mas basicamente significa não usar mais ActiveModel :: Errors. Eu fiz isso, funciona bem.

Como um aparte, aqui está uma maneira útil de incluir auxiliares em um modelo de apresentador / visualização sem poluir seu conjunto de métodos (porque ser capaz de fazer, por exemplo, MyPresenterOrViewModel.new.link_to(...)não faz sentido):

class MyPresenterOrViewModel
  def some_field
    helper.number_to_currency(amount, :precision => 0)
  end

  private

  def helper
    @helper ||= Class.new do
      include ActionView::Helpers::NumberHelper
    end.new
  end
end

Eu concordo com todos vocês que isso pode estar quebrando o padrão MVC, mas sempre há motivos para quebrar um padrão, no meu caso eu precisava desses métodos de formatador de moeda para usá-los em um filtro de modelo ( Líquido no meu caso).

No final, descobri que poderia acessar esses métodos do formatador de moeda usando coisas como estas:

ActionController::Base.helpers.number_to_currency

Eu sei que este tópico é muito antigo, mas alguém pode procurar solução para este problema no Rails 4+. Os desenvolvedores adicionaram ActiveSupport :: NumberHelper, que pode ser usado sem acessar módulos / classes relacionados à visualização usando:

ActiveSupport::NumberHelper.number_to_currency(amount, precision: 0)

Você também precisa incluir o ActionView :: Helpers :: NumberHelper

class Job < ActiveRecord::Base
  include ActionView::Helpers::NumberHelper
  include JobsHelper
  def details
    return "Only " + to_dollar(part_amount_received) + 
           " out of " + to_dollar(price) + " received."
  end
end

Pegando carona na @fguillenresposta de, eu queria substituir o number_to_currencymétodo em meu ApplicationHelpermódulo para que se o valor fosse 0ou blankque ele gerasse um traço.

Aqui está meu código, caso vocês achem algo assim útil:

module ApplicationHelper
  def number_to_currency(value)
    if value == 0 or value.blank?
      raw "–"
    else
      ActionController::Base.helpers.number_to_currency(value)
    end
  end
end

Você pode usar view_context.number_to_currencydiretamente de seu controlador ou modelo.

O método de @fguillen é bom, embora aqui esteja uma abordagem um pouco mais limpa, especialmente considerando que a pergunta faz duas referências a to_dollar. Vou demonstrar primeiro usando o código de Ryan Bates ( http://railscasts.com/episodes/132-helpers-outside-views ).

def description
  "This category has #{helpers.pluralize(products.count, 'product')}."
end

def helpers
  ActionController::Base.helpers
end

Observe a chamada helpers.pluralize. Isso é possível devido à definição do método ( def helpers), que simplesmente retorna ActionController::Base.helpers. Portanto, helpers.pluralizeé abreviação de ActionController::Base.helpers.pluralize. Agora você pode usarhelpers.pluralize várias vezes, sem repetir os longos caminhos do módulo.

Então, suponho que a resposta a esta pergunta específica possa ser:

class Job < ActiveRecord::Base
  include JobsHelper
  def details
    return "Only " + helpers.to_dollar(part_amount_received) + 
           " out of " + helpers.to_dollar(price) + " received."
  end

  def helpers
    ActionView::Helpers::NumberHelper
  end
end

Não é uma boa prática, mas funciona para mim!

para importar, inclua ActionView :: Helpers :: NumberHelper no controlador. Por exemplo:

class ProveedorController < ApplicationController
    include ActionView::Helpers::NumberHelper
    # layout 'example'

    # GET /proveedores/filtro
    # GET /proveedores/filtro.json
    def filtro
        @proveedores = Proveedor.all

        respond_to do |format|
            format.html # filtro.html.erb
            format.json { render json: @proveedores }
        end
    end

    def valuacion_cartera
        @total_valuacion = 0
        facturas.each { |fac|
            @total_valuacion = @total_valuacion + fac.SumaDeImporte
        }

        @total = number_to_currency(@total_valuacion, :unit => "$ ")

        p '*'*80
        p @total_valuacion
    end
end

Espero que ajude você!

Realmente surpreso que nenhuma pessoa tenha falado sobre o uso de um decorador. O objetivo deles é resolver o problema que você está enfrentando e muito mais.

https://github.com/drapergem/draper

EDIT: Parece que a resposta aceita basicamente sugeriu fazer algo assim. Mas sim, você quer usar decoradores. Esta é uma ótima série de tutoriais para ajudá-lo a entender mais:

https://gorails.com/episodes/decorators-from-scratch?autoplay=1

PS - @ excid3 eu aceito meses de adesão grátis LOL

Você pode apenas include ActiveSupport::NumberHelpermodular, se não precisar de recursos adicionais definidos por ActionView.

https://github.com/rails/rails/blob/44260581bec06e4ce05f3dd838c8b4736fc7eb1d/actionview/lib/action_view/helpers/number_helper.rb#L383

Os métodos auxiliares geralmente são usados ​​para arquivos de exibição. Não é uma boa prática usar esses métodos na classe Model. Mas se você quiser usar, a resposta de Sam está ok. OU eu sugiro que você pode escrever seu próprio método personalizado.