Class: String

Inherits:
Object show all
Defined in:
lib/cassandra_mapper/core_ext/string/inflections.rb,
lib/cassandra_mapper/core_ext/string/multibyte.rb

Overview

String inflections define new methods on the String class to transform names for different purposes. For instance, you can figure out the name of a database from the name of a class.

"ScaleScore".tableize # => "scale_scores"

Instance Method Summary collapse

Instance Method Details

#camelize(first_letter = :upper) ⇒ Object Also known as: camelcase

By default, camelize converts strings to UpperCamelCase. If the argument to camelize is set to :lower then camelize produces lowerCamelCase.

camelize will also convert ‘/’ to ‘::’ which is useful for converting paths to namespaces.

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



51
52
53
54
55
56
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 51

def camelize(first_letter = :upper)
  case first_letter
    when :upper then CassandraMapper::Support::Inflector.camelize(self, true)
    when :lower then CassandraMapper::Support::Inflector.camelize(self, false)
  end
end

#classify ⇒ Object

Create a class name from a plural table name like Rails does for table names to models. Note that this returns a string and not a class. (To convert to an actual class follow classify with constantize.)

"egg_and_hams".classify # => "EggAndHam"
"posts".classify        # => "Post"

Singular names are not handled correctly.

"business".classify # => "Busines"



136
137
138
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 136

def classify
  CassandraMapper::Support::Inflector.classify(self)
end

#constantize ⇒ Object

constantize tries to find a declared constant with the name specified in the string. It raises a NameError when the name is not in CamelCase or is not initialized.

Examples

"Module".constantize # => Module
"Class".constantize  # => Class



38
39
40
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 38

def constantize
  CassandraMapper::Support::Inflector.constantize(self)
end

#dasherize ⇒ Object

Replaces underscores with dashes in the string.

"puni_puni" # => "puni-puni"



85
86
87
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 85

def dasherize
  CassandraMapper::Support::Inflector.dasherize(self)
end

#demodulize ⇒ Object

Removes the module part from the constant expression in the string.

"ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
"Inflections".demodulize                                       # => "Inflections"



93
94
95
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 93

def demodulize
  CassandraMapper::Support::Inflector.demodulize(self)
end

#foreign_key(separate_class_name_and_id_with_underscore = true) ⇒ Object

Creates a foreign key name from a class name. separate_class_name_and_id_with_underscore sets whether the method should put ‘_’ between the name and ‘id’.

Examples

"Message".foreign_key        # => "message_id"
"Message".foreign_key(false) # => "messageid"
"Admin::Post".foreign_key    # => "post_id"



157
158
159
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 157

def foreign_key(separate_class_name_and_id_with_underscore = true)
  CassandraMapper::Support::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
end

#humanize ⇒ Object

Capitalizes the first word, turns underscores into spaces, and strips ‘_id’. Like titleize, this is meant for creating pretty output.

"employee_salary" # => "Employee salary"
"author_id"       # => "Author"



145
146
147
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 145

def humanize
  CassandraMapper::Support::Inflector.humanize(self)
end

#is_utf8? ⇒ Boolean

Returns true if the string has UTF-8 semantics (a String used for purely byte resources is unlikely to have them), returns false otherwise.

Returns:

  • (Boolean) 


47
48
49
50
51
52
53
54
55
56
 
# File 'lib/cassandra_mapper/core_ext/string/multibyte.rb', line 47

def is_utf8? #:nodoc
  case encoding
  when Encoding::UTF_8
    valid_encoding?
  when Encoding::ASCII_8BIT, Encoding::US_ASCII
    dup.force_encoding(Encoding::UTF_8).valid_encoding?
  else
    false
  end
end

#mb_chars ⇒ Object

Multibyte proxy

mb_chars is a multibyte safe proxy for string methods.

In Ruby 1.8 and older it creates and returns an instance of the CassandraMapper::Support::Multibyte::Chars class which encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy class. If the proxy class doesn’t respond to a certain method, it’s forwarded to the encapsuled string.

name = 'Claus Müller'
name.reverse  #=> "rell??M sualC"
name.length   #=> 13

name.mb_chars.reverse.to_s   #=> "rellüM sualC"
name.mb_chars.length         #=> 12

In Ruby 1.9 and newer mb_chars returns self because String is (mostly) encoding aware. This means that it becomes easy to run one version of your code on multiple Ruby versions.

Method chaining

All the methods on the Chars proxy which normally return a string will return a Chars object. This allows method chaining on the result of any of these methods.

name.mb_chars.reverse.length #=> 12

Interoperability and configuration

The Chars object tries to be as interchangeable with String objects as possible: sorting and comparing between String and Char work like expected. The bang! methods change the internal string representation in the Chars object. Interoperability problems can be resolved easily with a to_s call.

For more information about the methods defined on the Chars proxy see CassandraMapper::Support::Multibyte::Chars. For information about how to change the default Multibyte behaviour see CassandraMapper::Support::Multibyte.



39
40
41
42
43
44
45
 
# File 'lib/cassandra_mapper/core_ext/string/multibyte.rb', line 39

def mb_chars
  if CassandraMapper::Support::Multibyte.proxy_class.consumes?(self)
    CassandraMapper::Support::Multibyte.proxy_class.new(self)
  else
    self
  end
end

#parameterize(sep = '-') ⇒ Object

Replaces special characters in a string so that it may be used as part of a ‘pretty’ URL.

Examples

class Person
  def to_param
    "#{id}-#{name.parameterize}"
  end
end

@person = Person.find(1)
# => #<Person id: 1, name: "Donald E. Knuth">

<%= link_to(@person.name, person_path %>
# => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>



112
113
114
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 112

def parameterize(sep = '-')
  CassandraMapper::Support::Inflector.parameterize(self, sep)
end

#pluralize ⇒ Object

Returns the plural form of the word in the string.

"post".pluralize             # => "posts"
"octopus".pluralize          # => "octopi"
"sheep".pluralize            # => "sheep"
"words".pluralize            # => "words"
"the blue mailman".pluralize # => "the blue mailmen"
"CamelOctopus".pluralize     # => "CamelOctopi"



15
16
17
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 15

def pluralize
  CassandraMapper::Support::Inflector.pluralize(self)
end

#singularize ⇒ Object

The reverse of pluralize, returns the singular form of a word in a string.

"posts".singularize            # => "post"
"octopi".singularize           # => "octopus"
"sheep".singularize            # => "sheep"
"word".singularize             # => "word"
"the blue mailmen".singularize # => "the blue mailman"
"CamelOctopi".singularize      # => "CamelOctopus"



27
28
29
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 27

def singularize
  CassandraMapper::Support::Inflector.singularize(self)
end

#tableize ⇒ Object

Creates the name of a table like Rails does for models to table names. This method uses the pluralize method on the last word in the string.

"RawScaledScorer".tableize # => "raw_scaled_scorers"
"egg_and_ham".tableize     # => "egg_and_hams"
"fancyCategory".tableize   # => "fancy_categories"



122
123
124
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 122

def tableize
  CassandraMapper::Support::Inflector.tableize(self)
end

#titleize ⇒ Object Also known as: titlecase

Capitalizes all the words and replaces some characters in the string to create a nicer looking title. titleize is meant for creating pretty output. It is not used in the Rails internals.

titleize is also aliased as titlecase.

"man from the boondocks".titleize # => "Man From The Boondocks"
"x-men: the last stand".titleize  # => "X Men: The Last Stand"



67
68
69
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 67

def titleize
  CassandraMapper::Support::Inflector.titleize(self)
end

#underscore ⇒ Object

The reverse of camelize. Makes an underscored, lowercase form from the expression in the string.

underscore will also change ‘::’ to ‘/’ to convert namespaces to paths.

"ActiveRecord".underscore         # => "active_record"
"ActiveRecord::Errors".underscore # => active_record/errors



78
79
80
 
# File 'lib/cassandra_mapper/core_ext/string/inflections.rb', line 78

def underscore
  CassandraMapper::Support::Inflector.underscore(self)
end