From b70239b0cfb5ea8c00ff6375d007a924e21b4515 Mon Sep 17 00:00:00 2001 From: Jeremy Kemper Date: Wed, 22 Apr 2009 00:40:14 -0700 Subject: Convert string extension modules to class reopens --- .../lib/active_support/core_ext/string.rb | 10 - .../lib/active_support/core_ext/string/access.rb | 181 ++++++------- .../lib/active_support/core_ext/string/behavior.rb | 18 +- .../active_support/core_ext/string/inflections.rb | 299 ++++++++++----------- .../active_support/core_ext/string/iterators.rb | 27 +- activesupport/lib/active_support/inflector.rb | 3 - 6 files changed, 247 insertions(+), 291 deletions(-) (limited to 'activesupport/lib/active_support') diff --git a/activesupport/lib/active_support/core_ext/string.rb b/activesupport/lib/active_support/core_ext/string.rb index 222199a9a4..98ad75429e 100644 --- a/activesupport/lib/active_support/core_ext/string.rb +++ b/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 diff --git a/activesupport/lib/active_support/core_ext/string/access.rb b/activesupport/lib/active_support/core_ext/string/access.rb index e806b321f1..57385d86d2 100644 --- a/activesupport/lib/active_support/core_ext/string/access.rb +++ b/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 diff --git a/activesupport/lib/active_support/core_ext/string/behavior.rb b/activesupport/lib/active_support/core_ext/string/behavior.rb index a93ca3027f..9d45fbca45 100644 --- a/activesupport/lib/active_support/core_ext/string/behavior.rb +++ b/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 \ No newline at end of file +end diff --git a/activesupport/lib/active_support/core_ext/string/inflections.rb b/activesupport/lib/active_support/core_ext/string/inflections.rb index 48e812aaf8..ea4ed61e42 100644 --- a/activesupport/lib/active_support/core_ext/string/inflections.rb +++ b/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 :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" - 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 :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" + 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) - # # => # - # - # <%= link_to(@person.name, person_path %> - # # => Donald E. Knuth - 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) + # # => # + # + # <%= link_to(@person.name, person_path %> + # # => Donald E. Knuth + 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 diff --git a/activesupport/lib/active_support/core_ext/string/iterators.rb b/activesupport/lib/active_support/core_ext/string/iterators.rb index 6ca6375fda..472de7bc24 100644 --- a/activesupport/lib/active_support/core_ext/string/iterators.rb +++ b/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 diff --git a/activesupport/lib/active_support/inflector.rb b/activesupport/lib/active_support/inflector.rb index f14f6a6490..614afa1bd6 100644 --- a/activesupport/lib/active_support/inflector.rb +++ b/activesupport/lib/active_support/inflector.rb @@ -404,6 +404,3 @@ end # 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 -- cgit v1.2.3