Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Convert string extension modules to class reopens

  • Loading branch information...
commit b70239b0cfb5ea8c00ff6375d007a924e21b4515 1 parent 35afad6
@jeremy jeremy authored
View
10 activesupport/lib/active_support/core_ext/string.rb
@@ -1,19 +1,9 @@
-# encoding: utf-8
-
require 'active_support/core_ext/string/conversions'
require 'active_support/core_ext/string/filters'
require 'active_support/core_ext/string/multibyte'
require 'active_support/core_ext/string/starts_ends_with'
-
require 'active_support/core_ext/string/inflections'
require 'active_support/core_ext/string/access'
require 'active_support/core_ext/string/iterators'
require 'active_support/core_ext/string/xchar'
require 'active_support/core_ext/string/behavior'
-
-class String #:nodoc:
- include ActiveSupport::CoreExtensions::String::Access
- include ActiveSupport::CoreExtensions::String::Inflections
- include ActiveSupport::CoreExtensions::String::Iterators
- include ActiveSupport::CoreExtensions::String::Behavior
-end
View
181 activesupport/lib/active_support/core_ext/string/access.rb
@@ -1,105 +1,96 @@
-module ActiveSupport #:nodoc:
- module CoreExtensions #:nodoc:
- module String #:nodoc:
- unless '1.9'.respond_to?(:force_encoding)
- # Makes it easier to access parts of a string, such as specific characters and substrings.
- module Access
- # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
- #
- # Examples:
- # "hello".at(0) # => "h"
- # "hello".at(4) # => "o"
- # "hello".at(10) # => nil
- def at(position)
- mb_chars[position, 1].to_s
- end
-
- # Returns the remaining of the string from the +position+ treating the string as an array (where 0 is the first character).
- #
- # Examples:
- # "hello".from(0) # => "hello"
- # "hello".from(2) # => "llo"
- # "hello".from(10) # => nil
- def from(position)
- mb_chars[position..-1].to_s
- end
-
- # Returns the beginning of the string up to the +position+ treating the string as an array (where 0 is the first character).
- #
- # Examples:
- # "hello".to(0) # => "h"
- # "hello".to(2) # => "hel"
- # "hello".to(10) # => "hello"
- def to(position)
- mb_chars[0..position].to_s
- end
+class String
+ unless '1.9'.respond_to?(:force_encoding)
+ # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
+ #
+ # Examples:
+ # "hello".at(0) # => "h"
+ # "hello".at(4) # => "o"
+ # "hello".at(10) # => nil
+ def at(position)
+ mb_chars[position, 1].to_s
+ end
+
+ # Returns the remaining of the string from the +position+ treating the string as an array (where 0 is the first character).
+ #
+ # Examples:
+ # "hello".from(0) # => "hello"
+ # "hello".from(2) # => "llo"
+ # "hello".from(10) # => nil
+ def from(position)
+ mb_chars[position..-1].to_s
+ end
+
+ # Returns the beginning of the string up to the +position+ treating the string as an array (where 0 is the first character).
+ #
+ # Examples:
+ # "hello".to(0) # => "h"
+ # "hello".to(2) # => "hel"
+ # "hello".to(10) # => "hello"
+ def to(position)
+ mb_chars[0..position].to_s
+ end
- # Returns the first character of the string or the first +limit+ characters.
- #
- # Examples:
- # "hello".first # => "h"
- # "hello".first(2) # => "he"
- # "hello".first(10) # => "hello"
- def first(limit = 1)
- if limit == 0
- ''
- elsif limit >= size
- self
- else
- mb_chars[0...limit].to_s
- end
- end
+ # Returns the first character of the string or the first +limit+ characters.
+ #
+ # Examples:
+ # "hello".first # => "h"
+ # "hello".first(2) # => "he"
+ # "hello".first(10) # => "hello"
+ def first(limit = 1)
+ if limit == 0
+ ''
+ elsif limit >= size
+ self
+ else
+ mb_chars[0...limit].to_s
+ end
+ end
- # Returns the last character of the string or the last +limit+ characters.
- #
- # Examples:
- # "hello".last # => "o"
- # "hello".last(2) # => "lo"
- # "hello".last(10) # => "hello"
- def last(limit = 1)
- if limit == 0
- ''
- elsif limit >= size
- self
- else
- mb_chars[(-limit)..-1].to_s
- end
- end
- end
+ # Returns the last character of the string or the last +limit+ characters.
+ #
+ # Examples:
+ # "hello".last # => "o"
+ # "hello".last(2) # => "lo"
+ # "hello".last(10) # => "hello"
+ def last(limit = 1)
+ if limit == 0
+ ''
+ elsif limit >= size
+ self
else
- module Access #:nodoc:
- def at(position)
- self[position]
- end
+ mb_chars[(-limit)..-1].to_s
+ end
+ end
+ else
+ def at(position)
+ self[position]
+ end
- def from(position)
- self[position..-1]
- end
+ def from(position)
+ self[position..-1]
+ end
- def to(position)
- self[0..position]
- end
+ def to(position)
+ self[0..position]
+ end
- def first(limit = 1)
- if limit == 0
- ''
- elsif limit >= size
- self
- else
- to(limit - 1)
- end
- end
+ def first(limit = 1)
+ if limit == 0
+ ''
+ elsif limit >= size
+ self
+ else
+ to(limit - 1)
+ end
+ end
- def last(limit = 1)
- if limit == 0
- ''
- elsif limit >= size
- self
- else
- from(-limit)
- end
- end
- end
+ def last(limit = 1)
+ if limit == 0
+ ''
+ elsif limit >= size
+ self
+ else
+ from(-limit)
end
end
end
View
18 activesupport/lib/active_support/core_ext/string/behavior.rb
@@ -1,13 +1,7 @@
-module ActiveSupport #:nodoc:
- module CoreExtensions #:nodoc:
- module String #:nodoc:
- module Behavior
- # Enable more predictable duck-typing on String-like classes. See
- # Object#acts_like?.
- def acts_like_string?
- true
- end
- end
- end
+class String
+ # Enable more predictable duck-typing on String-like classes. See
+ # Object#acts_like?.
+ def acts_like_string?
+ true
end
-end
+end
View
299 activesupport/lib/active_support/core_ext/string/inflections.rb
@@ -1,167 +1,160 @@
-require 'active_support/inflector' unless defined?(ActiveSupport::Inflector)
+# 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"
-module ActiveSupport #:nodoc:
- module CoreExtensions #:nodoc:
- module String #:nodoc:
- # 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"
- module Inflections
- # 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"
- def pluralize
- Inflector.pluralize(self)
- end
+class String
+ # 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"
+ def pluralize
+ ActiveSupport::Inflector.pluralize(self)
+ end
- # 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"
- def singularize
- Inflector.singularize(self)
- end
+ # 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"
+ def singularize
+ ActiveSupport::Inflector.singularize(self)
+ end
- # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
- # is set to <tt>:lower</tt> 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"
- def camelize(first_letter = :upper)
- case first_letter
- when :upper then Inflector.camelize(self, true)
- when :lower then Inflector.camelize(self, false)
- end
- end
- alias_method :camelcase, :camelize
+ # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
+ # is set to <tt>:lower</tt> 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"
+ def camelize(first_letter = :upper)
+ case first_letter
+ when :upper then ActiveSupport::Inflector.camelize(self, true)
+ when :lower then ActiveSupport::Inflector.camelize(self, false)
+ end
+ end
+ alias_method :camelcase, :camelize
- # 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"
- def titleize
- Inflector.titleize(self)
- end
- alias_method :titlecase, :titleize
+ # 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"
+ def titleize
+ ActiveSupport::Inflector.titleize(self)
+ end
+ alias_method :titlecase, :titleize
- # 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
- def underscore
- Inflector.underscore(self)
- end
+ # 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
+ def underscore
+ ActiveSupport::Inflector.underscore(self)
+ end
- # Replaces underscores with dashes in the string.
- #
- # "puni_puni" # => "puni-puni"
- def dasherize
- Inflector.dasherize(self)
- end
+ # Replaces underscores with dashes in the string.
+ #
+ # "puni_puni" # => "puni-puni"
+ def dasherize
+ ActiveSupport::Inflector.dasherize(self)
+ end
- # Removes the module part from the constant expression in the string.
- #
- # "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
- # "Inflections".demodulize # => "Inflections"
- def demodulize
- Inflector.demodulize(self)
- end
+ # Removes the module part from the constant expression in the string.
+ #
+ # "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+ # "Inflections".demodulize # => "Inflections"
+ def demodulize
+ ActiveSupport::Inflector.demodulize(self)
+ end
- # 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>
- def parameterize(sep = '-')
- Inflector.parameterize(self, sep)
- end
+ # 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>
+ def parameterize(sep = '-')
+ ActiveSupport::Inflector.parameterize(self, sep)
+ end
- # 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"
- def tableize
- Inflector.tableize(self)
- end
+ # 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"
+ def tableize
+ ActiveSupport::Inflector.tableize(self)
+ end
- # 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"
- def classify
- Inflector.classify(self)
- end
-
- # 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"
- def humanize
- Inflector.humanize(self)
- end
+ # 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"
+ def classify
+ ActiveSupport::Inflector.classify(self)
+ end
+
+ # 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"
+ def humanize
+ ActiveSupport::Inflector.humanize(self)
+ end
- # 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"
- def foreign_key(separate_class_name_and_id_with_underscore = true)
- Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
- end
+ # 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"
+ def foreign_key(separate_class_name_and_id_with_underscore = true)
+ ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+ end
- # +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
- def constantize
- Inflector.constantize(self)
- end
- end
- end
+ # +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
+ def constantize
+ ActiveSupport::Inflector.constantize(self)
end
end
View
27 activesupport/lib/active_support/core_ext/string/iterators.rb
@@ -1,22 +1,13 @@
-autoload :StringScanner, 'strscan' unless defined? :StringScanner
+unless '1.9'.respond_to?(:each_char)
+ autoload :StringScanner, 'strscan' unless defined? :StringScanner
-module ActiveSupport #:nodoc:
- module CoreExtensions #:nodoc:
- module String #:nodoc:
- # Custom string iterators
- module Iterators
- def self.append_features(base)
- super unless '1.9'.respond_to?(:each_char)
- end
-
- # Yields a single-character string for each character in the string.
- # When $KCODE = 'UTF8', multi-byte characters are yielded appropriately.
- def each_char
- scanner, char = StringScanner.new(self), /./mu
- while c = scanner.scan(char)
- yield c
- end
- end
+ class String
+ # Yields a single-character string for each character in the string.
+ # When $KCODE = 'UTF8', multi-byte characters are yielded appropriately.
+ def each_char
+ scanner, char = StringScanner.new(self), /./mu
+ while c = scanner.scan(char)
+ yield c
end
end
end
View
3  activesupport/lib/active_support/inflector.rb
@@ -404,6 +404,3 @@ def ordinalize(number)
# in case active_support/inflector is required without the rest of active_support
require 'active_support/inflections'
require 'active_support/core_ext/string/inflections'
-unless String.included_modules.include?(ActiveSupport::CoreExtensions::String::Inflections)
- String.send :include, ActiveSupport::CoreExtensions::String::Inflections
-end

3 comments on commit b70239b

@vandrijevik

Can you please enlighten us as to why this is being done? Having extensions as Modules that get included is much cleaner and clearer, IMHO, especially since String.ancestors will then show where methods come from. This approach hides that.

@greatseth

Implementation is simpler this way, and since you would now have to be explicit about which extensions you are using, that would help avoid obfuscation about where behavior came from.

Just a guess, though..

@jeremy
Owner

In a nutshell:

  • single require to pull in a feature instead of require + include
  • less cruft dangling from the core class ancestor chains
  • fewer Modules saves on memory (surprisingly so)
  • consolidated documentation: look at the core class for a quick overview of its extensions

We'll talk about this more in the next Edge blog post.

Please sign in to comment.
Something went wrong with that request. Please try again.