ruby-on-rails - ruby convert snake case to camelcase

Convertendo string de snake_case para CamelCase em Ruby (6)

Benchmark para soluções Pure Ruby

Eu peguei todas as possibilidades que eu tinha em mente para fazer isso com puro código ruby, aqui estão elas:

capitalizar e gsub

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

dividir e mapear usando & shorthand (graças à resposta de user3869936)
```
"app_user".split('_').map(&:capitalize).join
```
dividir e mapear (graças à resposta do Sr. Black)
```
"app_user".split('_').map{|e| e.capitalize}.join
```

E aqui está o Benchmark para todos estes, 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)

Eu estou tentando converter um nome de caso de cobra para o caso de camelo. Existe algum método embutido?

Por exemplo: "app_user" para "AppUser"

(Eu tenho uma string "app_user" eu quero converter isso para modelar AppUser ).

A maioria dos outros métodos listados aqui são específicos do Rails. Se você quer fazer isso com o Ruby puro, o seguinte é a maneira mais concisa que eu criei (graças ao @ ulysse-bn para a melhoria sugerida)

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

Eu me sinto um pouco desconfortável para adicionar mais respostas aqui. Decidiu optar pela abordagem de puro rubi mais legível e mínima, desconsiderando o bom benchmark de @ ulysse-bn. Enquanto :class modo de :class é uma cópia de @ user3869936, o modo :method não aparece 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

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"

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

Para fins de aprendizagem:

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"

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

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

Se você quiser obter uma classe real, você deve usar String#constantize em cima disso.

"app_user".camelize.constantize

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 questão (não é específico para o título da questão). Se alguém está tentando converter uma string para camelo, eles devem usar a resposta de Sergio . O questionador afirma que ele quer converter app_user para AppUser (não App_user ), daí esta resposta ..