Estoy tratando de convertir un nombre de serpiente a camello. ¿Hay algún método incorporado?

Por ejemplo: "app_user"a"AppUser"

(Tengo una cadena "app_user"que quiero convertir eso a modelo AppUser).

Si está utilizando Rails, String # camelize es lo que está buscando.

  "active_record".camelize                # => "ActiveRecord"
  "active_record".camelize(:lower)        # => "activeRecord"

Si desea obtener una clase real, debe usar String # constantize además de eso.

"app_user".camelize.constantize

¿Que tal este?

"hello_world".split('_').collect(&:capitalize).join #=> "HelloWorld"

Encontrado en los comentarios aquí: clasificar una cadena de Ruby

Ver comentario de Wayne Conrad

Si usa rieles, use classify. Maneja bien los casos de borde.

"app_user".classify # => AppUser
"user_links".classify   # => UserLink

Nota:

Esta respuesta es específica de la descripción dada en la pregunta (no es específica del título de la pregunta). Si uno está tratando de convertir una cadena a camello, debe usar la respuesta de Sergio . El interrogador afirma que quiere convertirse app_usera AppUser(no App_user), de ahí esta respuesta.

Fuente: http://rubydoc.info/gems/extlib/0.9.15/String#camel_case-instance_method

Para fines de aprendizaje:

class String
  def camel_case
    return self if self !~ /_/ && self =~ /[A-Z]+.*/
    split('_').map{|e| e.capitalize}.join
  end
end

"foo_bar".camel_case          #=> "FooBar"

Y para la variante lowerCase:

class String
  def camel_case_lower
    self.split('_').inject([]){ |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
  end
end

"foo_bar".camel_case_lower          #=> "fooBar"

Punto de referencia para soluciones puras de Ruby

Aproveché todas las posibilidades que tenía en mente para hacerlo con código ruby ​​puro, aquí están:

• capitalizar y gsub

  'app_user'.capitalize.gsub(/_(\w)/){$1.upcase}

• dividir y mapear usando &taquigrafía (gracias a la respuesta del usuario 3869936)

  'app_user'.split('_').map(&:capitalize).join

• división y mapa (gracias a la respuesta del Sr. Black)

  'app_user'.split('_').map{|e| e.capitalize}.join

Y aquí está el punto de referencia para todos estos, podemos ver que gsub es bastante malo para esto. Usé 126 080 palabras.

                              user     system      total        real
capitalize and gsub  :      0.360000   0.000000   0.360000 (  0.357472)
split and map, with &:      0.190000   0.000000   0.190000 (  0.189493)
split and map        :      0.170000   0.000000   0.170000 (  0.171859)

Llegué buscando el inverso de tu pregunta, pasando de un caso de camellos a un caso de serpientes. Use guión bajo para eso (no decamelizar):

AppUser.name.underscore # => "app_user"

o, si ya tiene una cadena de camello:

"AppUser".underscore # => "app_user"

o, si desea obtener el nombre de la tabla, probablemente es por eso que desea el caso de la serpiente:

AppUser.name.tableize # => "app_users"

Me siento un poco incómodo para agregar más respuestas aquí. Decidí optar por el enfoque de rubí puro más legible y mínimo, sin tener en cuenta el buen punto de referencia de @ ulysse-bn. Si bien el :classmodo es una copia de @ user3869936, el :methodmodo que no veo en ninguna otra respuesta aquí.

  def snake_to_camel_case(str, mode: :class)
    case mode
    when :class
      str.split('_').map(&:capitalize).join
    when :method
      str.split('_').inject { |m, p| m + p.capitalize }
    else
      raise "unknown mode #{mode.inspect}"
    end
  end

El resultado es:

[28] pry(main)> snake_to_camel_case("asd_dsa_fds", mode: :class)
=> "AsdDsaFds"
[29] pry(main)> snake_to_camel_case("asd_dsa_fds", mode: :method)
=> "asdDsaFds"

La mayoría de los otros métodos enumerados aquí son específicos de Rails. Si quieres hacer esto con Ruby puro, la siguiente es la forma más concisa que se me ocurrió (gracias a @ ulysse-bn por la mejora sugerida)

x="this_should_be_camel_case"
x.gsub(/(?:_|^)(\w)/){$1.upcase}
    #=> "ThisShouldBeCamelCase"

Extienda la cadena para agregar Camelize

En Ruby puro, podría extender la clase de cadena utilizando exactamente el mismo código de Rails .camelize

class String
  def camelize(uppercase_first_letter = true)
    string = self
    if uppercase_first_letter
      string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
    else
      string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
    end
    string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub("/", "::")
  end
end