Estou tentando converter um nome de estojo de cobra para estojo de camelo. Existem métodos internos?

Por exemplo: "app_user"para"AppUser"

(Eu tenho uma string que "app_user"eu quero converter isso em modelo AppUser).

Se você estiver usando o Rails, String # camelize é o que você está procurando.

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

Se você deseja obter uma classe real, use String # constantize em cima disso.

"app_user".camelize.constantize

Que tal este?

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

Encontrado nos comentários aqui: Classifique uma string Ruby

Ver comentário de Wayne Conrad

Se você usa Rails, use classify. Ele lida bem com casos de borda.

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

Nota:

Esta resposta é específica para a descrição dada na pergunta (não é específica para o título da pergunta). Se alguém estiver tentando converter uma string em caixa de camelo, deve usar a resposta de Sergio . O interlocutor afirma que ele deseja converter app_userpara AppUser(não App_user), portanto, esta resposta ..

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

Para fins de aprendizado:

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"

E para a 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"

Referência para soluções Ruby puras

Eu tomei todas as possibilidades que eu tinha em mente para fazê-lo com código ruby ​​puro, aqui estão elas:

• capitalizar e gsub

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

• dividir e mapear usando &abreviação (graças à resposta do usuário3869936)

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

• divisão e mapa (graças à resposta do Sr. Black)

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

E aqui está o Benchmark para todos esses, podemos ver que o gsub é muito ruim para isso. Eu usei 126 080 palavras.

                              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)

Cheguei aqui procurando o inverso da sua pergunta, passando de estojo de camelo para estojo de cobra. Use sublinhado para isso (não decamelize):

AppUser.name.underscore # => "app_user"

ou, se você já tiver uma sequência de camel case:

"AppUser".underscore # => "app_user"

ou, se você deseja obter o nome da tabela, provavelmente é por isso que deseja o caso da cobra:

AppUser.name.tableize # => "app_users"

Sinto-me um pouco desconfortável ao adicionar mais respostas aqui. Decidiu optar pela abordagem de rubi puro mais legível e mínima, desconsiderando a boa referência do @ ulysse-bn. Embora :classmode seja uma cópia de @ user3869936, o :methodmodo que não vejo em nenhuma outra resposta aqui.

  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

O resultado é:

[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"

A maioria dos outros métodos listados aqui é específica do Rails. Se você quiser fazer isso com Ruby puro, a seguir, é a maneira mais concisa que eu criei (obrigado a @ ulysse-bn pela melhoria sugerida)

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

Estender String para adicionar Camelize

No Ruby puro, você pode estender a classe de string usando exatamente o mesmo código do 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