Class: String

Inherits:
Object show all
Includes:
ActiveSupport::CoreExtensions::String::Access, ActiveSupport::CoreExtensions::String::Behavior, ActiveSupport::CoreExtensions::String::Conversions, ActiveSupport::CoreExtensions::String::Filters, ActiveSupport::CoreExtensions::String::Inflections, ActiveSupport::CoreExtensions::String::Iterators, ActiveSupport::CoreExtensions::String::Multibyte, ActiveSupport::CoreExtensions::String::StartsEndsWith
Defined in:
lib/active_support/core_ext/string.rb,
lib/active_support/json/encoders/string.rb,
lib/active_support/core_ext/object/blank.rb,
lib/active_support/core_ext/string/bytesize.rb,
lib/active_support/core_ext/string/output_safety.rb,
lib/active_support/vendor/builder-2.1.2/builder/xchar.rb,
lib/active_support/vendor/i18n-0.3.7/i18n/core_ext/string/interpolate.rb

Overview

Extension for String class. This feature is included in Ruby 1.9 or later but not occur TypeError.

String#% method which accept “named argument”. The translator can know the meaning of the msgids using “named argument” instead of %s/%d style.

Constant Summary collapse

INTERPOLATION_PATTERN = 
Regexp.union(
  /%\{(\w+)\}/,                               # matches placeholders like "%{foo}"
  /%<(\w+)>(.*?\d*\.?\d*[bBdiouxXeEfgGcps])/  # matches placeholders like "%<foo>.d"
)
INTERPOLATION_PATTERN_WITH_ESCAPE = 
Regexp.union(
  /%%/,
  INTERPOLATION_PATTERN
)

Instance Method Summary collapse

Methods included from ActiveSupport::CoreExtensions::String::Multibyte

#chars, #is_utf8?, #mb_chars

Methods included from ActiveSupport::CoreExtensions::String::Behavior

#acts_like_string?

Methods included from ActiveSupport::CoreExtensions::String::Iterators

append_features, #each_char

Methods included from ActiveSupport::CoreExtensions::String::StartsEndsWith

append_features, #ends_with?, #starts_with?

Methods included from ActiveSupport::CoreExtensions::String::Inflections

#camelize, #classify, #constantize, #dasherize, #demodulize, #foreign_key, #humanize, #parameterize, #pluralize, #singularize, #tableize, #titleize, #underscore

Methods included from ActiveSupport::CoreExtensions::String::Filters

#squish, #squish!

Methods included from ActiveSupport::CoreExtensions::String::Conversions

#ord, #to_date, #to_datetime, #to_time

Methods included from ActiveSupport::CoreExtensions::String::Access

#at, #first, #from, #last, #to

Instance Method Details

#%(args) ⇒ Object

% uses self (i.e. the String) as a format specification and returns the result of applying it to the given arguments. In other words it interpolates the given arguments to the string according to the formats the string defines.

There are three ways to use it:

  • Using a single argument or Array of arguments.

    This is the default behaviour of the String class. See Kernel#sprintf for more details about the format string.

    Example:

    "%d %s" % [1, "message"]
# => "1 message"

  • Using a Hash as an argument and unformatted, named placeholders.

    When you pass a Hash as an argument and specify placeholders with %foo it will interpret the hash values as named arguments.

    Example:

    "%{firstname}, %{lastname}" % {:firstname => "Masao", :lastname => "Mutoh"}
# => "Masao Mutoh"

  • Using a Hash as an argument and formatted, named placeholders.

    When you pass a Hash as an argument and specify placeholders with %<foo>d it will interpret the hash values as named arguments and format the value according to the formatting instruction appended to the closing >.

    Example:

    "%<integer>d, %<float>.1f" % { :integer => 10, :float => 43.4 }
# => "10, 43.3"



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/active_support/vendor/i18n-0.3.7/i18n/core_ext/string/interpolate.rb', line 80

def %(args)
  if args.kind_of?(Hash)
    dup.gsub(INTERPOLATION_PATTERN_WITH_ESCAPE) do |match|
      if match == '%%'
        '%'
      else
        key = ($1 || $2).to_sym
        raise KeyError unless args.has_key?(key)
        $3 ? sprintf("%#{$3}", args[key]) : args[key]
      end
    end
  elsif self =~ INTERPOLATION_PATTERN
    raise ArgumentError.new('one hash required')
  else
    result = gsub(/%([{<])/, '%%\1')
    result.send :'interpolate_without_ruby_19_syntax', args
  end
end

#add_with_safety(other) ⇒ Object Also known as: + 



135
136
137
138
139
140
141
142
 
# File 'lib/active_support/core_ext/string/output_safety.rb', line 135

def add_with_safety(other)
  result = add_without_safety(other)
  if html_safe? && also_html_safe?(other)
    result.html_safe!
  else
    result
  end
end

#as_json(options = nil) ⇒ Object

:nodoc:



6
7
8
 
# File 'lib/active_support/json/encoders/string.rb', line 6

def as_json(options = nil) #:nodoc:
  self
end

#as_str ⇒ Object 



117
118
119
 
# File 'lib/active_support/core_ext/string/output_safety.rb', line 117

def as_str
  self
end

#blank? ⇒ Boolean

Returns:

  • (Boolean) 


67
68
69
 
# File 'lib/active_support/core_ext/object/blank.rb', line 67

def blank?
  self !~ /\S/
end

#concat_with_safety(other_or_fixnum) ⇒ Object Also known as: << 



145
146
147
148
149
150
151
 
# File 'lib/active_support/core_ext/string/output_safety.rb', line 145

def concat_with_safety(other_or_fixnum)
  result = concat_without_safety(other_or_fixnum)
  unless html_safe? && also_html_safe?(other_or_fixnum)
    remove_instance_variable(:@_rails_html_safe) if defined?(@_rails_html_safe)
  end
  result
end

#html_safe ⇒ Object 



121
122
123
 
# File 'lib/active_support/core_ext/string/output_safety.rb', line 121

def html_safe
  ActiveSupport::SafeBuffer.new(self)
end

#html_safe! ⇒ Object 



129
130
131
132
133
 
# File 'lib/active_support/core_ext/string/output_safety.rb', line 129

def html_safe!
  ActiveSupport::Deprecation.warn("Use html_safe with your strings instead of html_safe! See http://yehudakatz.com/2010/02/01/safebuffers-and-rails-3-0/ for the full story.", caller)
  @_rails_html_safe = true
  self
end

#html_safe? ⇒ Boolean

Returns:

  • (Boolean) 


125
126
127
 
# File 'lib/active_support/core_ext/string/output_safety.rb', line 125

def html_safe?
  defined?(@_rails_html_safe)
end

#interpolate_without_ruby_19_syntax ⇒ Object

:nodoc:



31
 
# File 'lib/active_support/vendor/i18n-0.3.7/i18n/core_ext/string/interpolate.rb', line 31

alias :interpolate_without_ruby_19_syntax :%

#to_json(options = nil) ⇒ Object

:nodoc:



2
3
4
 
# File 'lib/active_support/json/encoders/string.rb', line 2

def to_json(options = nil) #:nodoc:
  ActiveSupport::JSON::Encoding.escape(self)
end

#to_xs ⇒ Object

XML escaped version of to_s



110
111
112
113
114
 
# File 'lib/active_support/vendor/builder-2.1.2/builder/xchar.rb', line 110

def to_xs
  unpack('U*').map {|n| n.xchr}.join # ASCII, UTF-8
rescue
  unpack('C*').map {|n| n.xchr}.join # ISO-8859-1, WIN-1252
end