Class: Hanami::Utils::String
- Inherits:
-
Object
- Object
- Hanami::Utils::String
- Extended by:
- Transproc::Composer, Transproc::Registry
- Defined in:
- lib/hanami/utils/string.rb
Overview
String on steroids
Direct Known Subclasses
Constant Summary collapse
- EMPTY_STRING =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
Empty string for #classify
""
- NAMESPACE_SEPARATOR =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
Separator between Ruby namespaces
"::"
- CLASSIFY_SEPARATOR =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
Separator for #classify
"_"
- TOKENIZE_REGEXP =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
Regexp for #tokenize
/\((.*)\)/.freeze
- TOKENIZE_SEPARATOR =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
Separator for #tokenize
"|"
- UNDERSCORE_SEPARATOR =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
Separator for #underscore
"/"
- UNDERSCORE_DIVISION_TARGET =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
gsub second parameter used in #underscore
'\1_\2'
- TITLEIZE_SEPARATOR =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
Separator for #titleize
" "
- CAPITALIZE_SEPARATOR =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
Separator for #capitalize
" "
- DASHERIZE_SEPARATOR =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
Separator for #dasherize
"-"
- CLASSIFY_WORD_SEPARATOR =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
Regexp for #classify
/#{CLASSIFY_SEPARATOR}|#{NAMESPACE_SEPARATOR}|#{UNDERSCORE_SEPARATOR}|#{DASHERIZE_SEPARATOR}/.freeze
Class Method Summary collapse
-
.bind(value, binding, fun) ⇒ Object
private
Extracted from ‘transproc` source code.
-
.capitalize(input) ⇒ ::String
Returns a capitalized version of the string.
-
.classify(input) ⇒ ::String
Returns a CamelCase version of the string.
-
.dasherize(input) ⇒ Object
Hanami::Utils::String.dasherize(‘hanami_utils’) # => ‘hanami-utils’.
-
.demodulize(input) ⇒ ::String
Returns the string without the Ruby namespace of the class.
-
.namespace(input) ⇒ ::String
Returns the top level namespace name.
- .pluralize(input) ⇒ ::String deprecated Deprecated.
-
.rsub(input, pattern, replacement) ⇒ ::String
Replaces the rightmost match of ‘pattern` with `replacement`.
- .singularize(input) ⇒ ::String deprecated Deprecated.
-
.titleize(input) ⇒ ::String
Returns a titleized version of the string.
-
.transform(input, *transformations) ⇒ ::String
Applies the given transformation(s) to ‘input`.
-
.underscore(input) ⇒ ::String
Returns a downcased and underscore separated version of the string.
Instance Method Summary collapse
- #==(other) ⇒ TrueClass, FalseClass (also: #eql?) deprecated Deprecated.
- #capitalize ⇒ Hanami::Utils::String deprecated Deprecated.
-
#classify ⇒ Hanami::Utils::String
deprecated
Deprecated.
Use String.classify
-
#dasherize ⇒ Hanami::Utils::String
deprecated
Deprecated.
Use String.dasherize
- #demodulize ⇒ Hanami::Utils::String deprecated Deprecated.
- #gsub(pattern, replacement = nil, &blk) ⇒ ::String deprecated Deprecated.
- #hash ⇒ Integer deprecated Deprecated.
- #initialize(string) ⇒ Hanami::Utils::String constructor deprecated Deprecated.
-
#method_missing(method_name, *args, &blk) ⇒ Object
private
Overrides Ruby’s method_missing in order to provide ::String interface.
-
#namespace ⇒ Hanami::Utils::String
deprecated
Deprecated.
Use String.namespace
- #pluralize ⇒ Hanami::Utils::String deprecated private Deprecated.
-
#respond_to_missing?(method_name, include_private = false) ⇒ Boolean
private
Overrides Ruby’s respond_to_missing? in order to support ::String interface.
-
#rsub(pattern, replacement) ⇒ Hanami::Utils::String
deprecated
Deprecated.
Use String.rsub
- #scan(pattern, &blk) ⇒ Array<::String> deprecated Deprecated.
- #singularize ⇒ Hanami::Utils::String deprecated private Deprecated.
- #split(pattern, limit = 0) ⇒ Array<::String> deprecated Deprecated.
-
#titleize ⇒ Hanami::Utils::String
deprecated
Deprecated.
Use String.titleize
- #to_s ⇒ ::String (also: #to_str) deprecated Deprecated.
- #tokenize { ... } ⇒ void deprecated Deprecated.
- #underscore ⇒ Hanami::Utils::String deprecated Deprecated.
Constructor Details
#initialize(string) ⇒ Hanami::Utils::String
Initialize the string
394 395 396 |
# File 'lib/hanami/utils/string.rb', line 394 def initialize(string) @string = string.to_s end |
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(method_name, *args, &blk) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Overrides Ruby’s method_missing in order to provide ::String interface
732 733 734 735 736 737 738 739 740 |
# File 'lib/hanami/utils/string.rb', line 732 def method_missing(method_name, *args, &blk) unless respond_to?(method_name) raise NoMethodError.new(%(undefined method `#{method_name}' for "#{@string}":#{self.class})) end s = @string.__send__(method_name, *args, &blk) s = self.class.new(s) if s.is_a?(::String) s end |
Class Method Details
.bind(value, binding, fun) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Extracted from ‘transproc` source code
‘transproc` is Copyright 2014 by Piotr Solnica ([email protected]), released under the MIT License
162 163 164 |
# File 'lib/hanami/utils/string.rb', line 162 def self.bind(value, binding, fun) binding.instance_exec(value, &fun) end |
.capitalize(input) ⇒ ::String
Returns a capitalized version of the string
203 204 205 206 207 208 |
# File 'lib/hanami/utils/string.rb', line 203 def self.capitalize(input) string = ::String.new(input.to_s) head, *tail = underscore(string).split(CLASSIFY_SEPARATOR) tail.unshift(head.capitalize).join(CAPITALIZE_SEPARATOR) end |
.classify(input) ⇒ ::String
Returns a CamelCase version of the string
222 223 224 225 226 227 228 229 230 231 232 |
# File 'lib/hanami/utils/string.rb', line 222 def self.classify(input) string = ::String.new(input.to_s) words = underscore(string).split(CLASSIFY_WORD_SEPARATOR).map!(&:capitalize) delimiters = underscore(string).scan(CLASSIFY_WORD_SEPARATOR) delimiters.map! do |delimiter| delimiter == CLASSIFY_SEPARATOR ? EMPTY_STRING : NAMESPACE_SEPARATOR end words.zip(delimiters).join end |
.dasherize(input) ⇒ Object
275 276 277 278 |
# File 'lib/hanami/utils/string.rb', line 275 def self.dasherize(input) string = ::String.new(input.to_s) underscore(string).split(CLASSIFY_SEPARATOR).join(DASHERIZE_SEPARATOR) end |
.demodulize(input) ⇒ ::String
Returns the string without the Ruby namespace of the class
294 295 296 |
# File 'lib/hanami/utils/string.rb', line 294 def self.demodulize(input) ::String.new(input.to_s).split(NAMESPACE_SEPARATOR).last end |
.namespace(input) ⇒ ::String
Returns the top level namespace name
312 313 314 |
# File 'lib/hanami/utils/string.rb', line 312 def self.namespace(input) ::String.new(input.to_s).split(NAMESPACE_SEPARATOR).first end |
.pluralize(input) ⇒ ::String
Returns a pluralized version of self.
331 332 333 334 |
# File 'lib/hanami/utils/string.rb', line 331 def self.pluralize(input) string = ::String.new(input.to_s) Inflector.pluralize(string) end |
.rsub(input, pattern, replacement) ⇒ ::String
Replaces the rightmost match of ‘pattern` with `replacement`
If the pattern cannot be matched, it returns the original string.
This method does NOT mutate the original string.
375 376 377 378 379 380 381 382 383 384 |
# File 'lib/hanami/utils/string.rb', line 375 def self.rsub(input, pattern, replacement) string = ::String.new(input.to_s) if i = string.rindex(pattern) s = string.dup s[i] = replacement s else string end end |
.singularize(input) ⇒ ::String
Returns a singularized version of self.
351 352 353 354 |
# File 'lib/hanami/utils/string.rb', line 351 def self.singularize(input) string = ::String.new(input.to_s) Inflector.singularize(string) end |
.titleize(input) ⇒ ::String
Returns a titleized version of the string
178 179 180 181 |
# File 'lib/hanami/utils/string.rb', line 178 def self.titleize(input) string = ::String.new(input.to_s) underscore(string).split(CLASSIFY_SEPARATOR).map(&:capitalize).join(TITLEIZE_SEPARATOR) end |
.transform(input, *transformations) ⇒ ::String
Applies the given transformation(s) to ‘input`
It performs a pipeline of transformations, by applying the given functions from ‘Hanami::Utils::String` and `::String`. The transformations are applied in the given order.
It doesn’t mutate the input, unless you use destructive methods from ‘::String`
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 |
# File 'lib/hanami/utils/string.rb', line 135 def self.transform(input, *transformations) fn = @__transformations__.fetch_or_store(transformations.hash) do compose do |fns| transformations.each do |transformation, *args| fns << if transformation.is_a?(Proc) transformation elsif contain?(transformation) self[transformation, *args] elsif input.respond_to?(transformation) t(:bind, input, ->(i) { i.public_send(transformation, *args) }) else raise NoMethodError.new(%(undefined method `#{transformation.inspect}' for #{input.inspect}:#{input.class})) # rubocop:disable Layout/LineLength end end end end fn.call(input) end |
.underscore(input) ⇒ ::String
Returns a downcased and underscore separated version of the string
Revised version of ‘ActiveSupport::Inflector.underscore` implementation
249 250 251 252 253 254 255 256 257 |
# File 'lib/hanami/utils/string.rb', line 249 def self.underscore(input) string = ::String.new(input.to_s) string.gsub!(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR) string.gsub!(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR) string.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET) string.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET) string.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET) string.downcase end |
Instance Method Details
#==(other) ⇒ TrueClass, FalseClass Also known as: eql?
Equality
644 645 646 |
# File 'lib/hanami/utils/string.rb', line 644 def ==(other) to_s == other end |
#capitalize ⇒ Hanami::Utils::String
Use capitalize
Returns a capitalized version of the string
438 439 440 441 442 443 444 |
# File 'lib/hanami/utils/string.rb', line 438 def capitalize head, *tail = underscore.split(CLASSIFY_SEPARATOR) self.class.new( tail.unshift(head.capitalize).join(CAPITALIZE_SEPARATOR) ) end |
#classify ⇒ Hanami::Utils::String
Use classify
Returns a CamelCase version of the string
458 459 460 461 462 463 464 465 466 467 |
# File 'lib/hanami/utils/string.rb', line 458 def classify words = underscore.split(CLASSIFY_WORD_SEPARATOR).map!(&:capitalize) delimiters = underscore.scan(CLASSIFY_WORD_SEPARATOR) delimiters.map! do |delimiter| delimiter == CLASSIFY_SEPARATOR ? EMPTY_STRING : NAMESPACE_SEPARATOR end self.class.new words.zip(delimiters).join end |
#dasherize ⇒ Hanami::Utils::String
Use dasherize
Returns a downcased and dash separated version of the string
511 512 513 |
# File 'lib/hanami/utils/string.rb', line 511 def dasherize self.class.new underscore.split(CLASSIFY_SEPARATOR).join(DASHERIZE_SEPARATOR) end |
#demodulize ⇒ Hanami::Utils::String
Use demodulize
Returns the string without the Ruby namespace of the class
530 531 532 |
# File 'lib/hanami/utils/string.rb', line 530 def demodulize self.class.new split(NAMESPACE_SEPARATOR).last end |
#gsub(pattern, replacement = nil, &blk) ⇒ ::String
Replaces the given pattern with the given replacement
670 671 672 673 674 675 676 |
# File 'lib/hanami/utils/string.rb', line 670 def gsub(pattern, replacement = nil, &blk) if block_given? @string.gsub(pattern, &blk) else @string.gsub(pattern, replacement) end end |
#hash ⇒ Integer
Returns the hash of the internal string
622 623 624 |
# File 'lib/hanami/utils/string.rb', line 622 def hash @string.hash end |
#namespace ⇒ Hanami::Utils::String
Use namespace
Returns the top level namespace name
549 550 551 |
# File 'lib/hanami/utils/string.rb', line 549 def namespace self.class.new split(NAMESPACE_SEPARATOR).first end |
#pluralize ⇒ Hanami::Utils::String
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Returns a pluralized version of self.
599 600 601 |
# File 'lib/hanami/utils/string.rb', line 599 def pluralize self.class.new Inflector.pluralize(self) end |
#respond_to_missing?(method_name, include_private = false) ⇒ Boolean
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Overrides Ruby’s respond_to_missing? in order to support ::String interface
746 747 748 |
# File 'lib/hanami/utils/string.rb', line 746 def respond_to_missing?(method_name, include_private = false) @string.respond_to?(method_name, include_private) end |
#rsub(pattern, replacement) ⇒ Hanami::Utils::String
Use rsub
Replaces the rightmost match of ‘pattern` with `replacement`
If the pattern cannot be matched, it returns the original string.
This method does NOT mutate the original string.
716 717 718 719 720 721 722 723 724 |
# File 'lib/hanami/utils/string.rb', line 716 def rsub(pattern, replacement) if i = rindex(pattern) s = @string.dup s[i] = replacement self.class.new s else self end end |
#scan(pattern, &blk) ⇒ Array<::String>
Iterates through the string, matching the pattern. Either return all those patterns, or pass them to the block.
687 688 689 |
# File 'lib/hanami/utils/string.rb', line 687 def scan(pattern, &blk) @string.scan(pattern, &blk) end |
#singularize ⇒ Hanami::Utils::String
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Returns a singularized version of self.
612 613 614 |
# File 'lib/hanami/utils/string.rb', line 612 def singularize self.class.new Inflector.singularize(self) end |
#split(pattern, limit = 0) ⇒ Array<::String>
Splits the string with the given pattern
658 659 660 |
# File 'lib/hanami/utils/string.rb', line 658 def split(pattern, limit = 0) @string.split(pattern, limit) end |
#titleize ⇒ Hanami::Utils::String
Use titleize
Returns a titleized version of the string
410 411 412 |
# File 'lib/hanami/utils/string.rb', line 410 def titleize self.class.new underscore.split(CLASSIFY_SEPARATOR).map(&:capitalize).join(TITLEIZE_SEPARATOR) end |
#to_s ⇒ ::String Also known as: to_str
Returns a string representation
632 633 634 |
# File 'lib/hanami/utils/string.rb', line 632 def to_s @string end |
#tokenize { ... } ⇒ void
This method returns an undefined value.
It iterates through the tokens and calls the given block. A token is a substring wrapped by ‘()` and separated by `|`.
575 576 577 578 579 580 581 582 583 584 585 586 587 588 |
# File 'lib/hanami/utils/string.rb', line 575 def tokenize if match = TOKENIZE_REGEXP.match(@string) pre = match.pre_match post = match.post_match tokens = match[1].split(TOKENIZE_SEPARATOR) tokens.each do |token| yield(self.class.new("#{pre}#{token}#{post}")) end else yield(self.class.new(@string)) end nil end |
#underscore ⇒ Hanami::Utils::String
Use underscore
Returns a downcased and underscore separated version of the string
Revised version of ‘ActiveSupport::Inflector.underscore` implementation
484 485 486 487 488 489 490 491 |
# File 'lib/hanami/utils/string.rb', line 484 def underscore new_string = gsub(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR) new_string.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET) new_string.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET) new_string.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET) new_string.downcase! self.class.new new_string end |