Rails antes de la validación strip whitespace mejores prácticas

Hay varias gemas para hacer esto automáticamente. Esas gemas funcionan de la misma manera de crear callback en before_validation. Una buena gema está en https://github.com/holli/auto_strip_attributes

gem "auto_strip_attributes", "~> 2.2"

class User < ActiveRecord::Base
  auto_strip_attributes :name, :nick, nullify: false, squish: true
  auto_strip_attributes :email
end

El stripping es a menudo una buena idea. Especialmente para espacios en blanco iniciales y finales. El usuario a menudo crea espacios finales al copiar / pegar valor a un formulario. Con los nombres y otras cadenas de identificación, también es posible que desee aplastar la cadena. Para que "Harry Potter" se convierta "Harry Potter" (opción de aplastar en la gema).

La respuesta de Charlie es buena, pero hay un poco de detalle. Aquí hay una versión más ajustada:

def clean_data
  # trim whitespace from beginning and end of string attributes
  attribute_names.each do |name|
    if send(name).respond_to?(:strip)
      send("#{name}=", send(name).strip)
    end
  end
end

La razón por la que usamos

self.foo = "bar"

En lugar de

foo = "bar"

En el contexto de los objetos ActiveRecord es que Ruby interpreta estos últimos como una asignación de variable local. Simplemente establecerá la variable foo en el ámbito de su método, en lugar de llamar al método "foo=" de su objeto.

Pero si está llamando a un método, no hay ambigüedad. El intérprete sabe que no eres se refiere a una variable local llamada foo porque no hay ninguna. Así por ejemplo con:

self.foo = foo + 1

Necesita usar "self" para la tarea, pero no para leer el valor actual.

Me gustaría agregar una trampa que podría experimentar con las soluciones "before_validations" anteriores. Tomemos este ejemplo:

u = User.new(name: " lala")
u.name # => " lala"
u.save
u.name # => "lala"

Esto significa que tiene un comportamiento inconsistente basado en si su objeto fue guardado o no. Si desea abordar esto, le sugiero otra solución a su problema: sobrescribir los métodos de configuración correspondientes.

class User < ActiveRecord::Base
  def name=(name)
    write_attribute(:name, name.try(:strip))
  end
end

También me gusta este enfoque porque no te obliga a habilitar el stripping para todos los atributos que lo soportan, a diferencia del attribute_names.each mencionado anteriormente. Además, no se requieren devoluciones de llamada.

Me gusta la respuesta de Karl, pero ¿hay una manera de hacerlo sin hacer referencia a cada uno de los atributos por nombre? Es decir, ¿hay una manera de simplemente ejecutar a través de los atributos del modelo y la tira de llamadas en cada uno (si responde a ese método)?

Esto sería deseable para no tener que actualizar el método remove_whitespace cada vez que cambie el modelo.

UPDATE

Veo que Karl insinuó que podrías querer hacer este tipo de cosas. No supe inmediatamente cómo podría hacerse, pero aquí hay algo que funciona para mí como se describió anteriormente. Probablemente hay una mejor manera de hacerlo, pero esto funciona:

def clean_data
  # trim whitespace from beginning and end of string attributes
  attribute_names().each do |name|
  if self.send(name.to_sym).respond_to?(:strip)
    self.send("#{name}=".to_sym, self.send(name).strip)
  end
end

Fin

Si tiene acceso a ActiveSupport, utilice squish en lugar de strip.

Http://api.rubyonrails.org/classes/String.html#method-i-squish

En su lugar podemos escribir un método mejor más genérico independientemente de lo que pueda ser el tipo de atributos con el objeto (podría tener 3 campos de tipo de cadena, pocos booleanos, pocos numéricos)

before_validation :strip_input_fields


def strip_input_fields
  self.attributes.each do |key, value|
    self[key] = value.strip if value.respond_to?("strip")
  end
end

¡Espero que will ayude a alguien!

StripAttributes Gem

Usé strip_attributes. Es realmente impresionante y fácil de implementar.

Comportamiento predeterminado

class DrunkPokerPlayer < ActiveRecord::Base
  strip_attributes
end

De forma predeterminada, esto solo eliminará los espacios en blanco iniciales y finales y actuará sobre todos los atributos del modelo. Esto es ideal porque no es destructivo y no requiere que especifique qué atributos deben ser rayados.

Usando except

# all attributes will be stripped except :boxers
class SoberPokerPlayer < ActiveRecord::Base
  strip_attributes :except => :boxers
end

Usando only

# only :shoe, :sock, and :glove attributes will be stripped
class ConservativePokerPlayer < ActiveRecord::Base
  strip_attributes :only => [:shoe, :sock, :glove]
end

Utilizando allow_empty

# Empty attributes will not be converted to nil
class BrokePokerPlayer < ActiveRecord::Base
  strip_attributes :allow_empty => true
end

Usando collapse_spaces

# Sequential spaces in attributes will be collapsed to one space
class EloquentPokerPlayer < ActiveRecord::Base
  strip_attributes :collapse_spaces => true
end

Usando expresiones regulares

class User < ActiveRecord::Base
  # Strip off characters defined by RegEx
  strip_attributes :only => [:first_name, :last_name], :regex => /[^[:alpha:]\s]/
  # Strip off non-integers
  strip_attributes :only => [:phone], :regex => /[^0-9]/
end

Aquí hay un enfoque alternativo, si lo que más le preocupa es que los usuarios introduzcan datos incorrectamente en sus formularios de front-end...

# app/assets/javascripts/trim.inputs.js.coffee
$(document).on "change", "input", ->
  $(this).val $(this).val().trim()

Luego incluya el archivo en su solicitud.js si aún no estás incluyendo todo el árbol.

Esto asegurará que cada entrada obtenga espacios en blanco iniciales y finales eliminados antes de ser enviados para ser guardados por Rails. Está vinculado a document, y delegado a las entradas, por lo que cualquier entrada añadida a la página más tarde se procesará como bien.

Ventajas:

• No requiere enumerar atributos individuales por nombre
• No requiere ninguna metaprogramación
• No requiere dependencias de bibliotecas externas

Contras:

• Los datos enviados de cualquier otra manera que los formularios (por ejemplo, a través de API) no se recortarán
• No tiene características avanzadas como squish (pero podría agregarlo usted mismo)
• Como se mencionó en los comentarios, no funciona si JS es deshabilitado (¿pero quién codifica para eso?)

Reemplazar el atributo write methods es otra buena manera. Por ejemplo:

class MyModel
  def email=(value)
    super(value.try(:strip))
  end
end

Entonces cualquier parte de la aplicación que establezca el valor lo tendrá despojado, incluyendo assign_attributes y así sucesivamente.

Aunque podría adoptar un enfoque similar a la respuesta de Karl, prefiero una sintaxis más concisa con menos asignaciones:

def strip_whitespace
  self.name.try(:strip!)
  self.email.try(:strip!)
  self.nick.try(:strip!)
end

Como aún no puedo comentar, tendré que preguntar aquí: ¿qué método está dando el Argumententerror? strip, o responds_to?

Además, .strip elimina solo los espacios en blanco iniciales y finales. Si quieres que" Harry Potter " con dos espacios no sea aceptado, tendrías que usar una expresión regular o, más simplemente, podrías llamar .dividir, que elimina espacios, y volver a concatenar la cadena con un solo espacio.

En cuanto a si el stripping es una buena idea, no veo un problema cuando es solo el espacio en blanco inicial/final. Sin embargo, si hay varios espacios entre palabras, notificaría al usuario en lugar de eliminar automáticamente los espacios adicionales y darle al usuario un inicio de sesión que no es lo que envió.

Otra opción de gema es attribute_normalizer :

# By default it will strip leading and trailing whitespace
# and set to nil if blank.
normalize_attributes :author, :publisher

: strip Eliminará los espacios en blanco iniciales y finales.

normalize_attribute  :author, :with => :strip