activesupport 1.2.4 → 8.1.2

data/lib/active_support/core_ext/string/multibyte.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "active_support/multibyte"
+
+class String
+  # == Multibyte proxy
+  #
+  # +mb_chars+ is a multibyte safe proxy for string methods.
+  #
+  # It creates and returns an instance of the ActiveSupport::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 encapsulated string.
+  #
+  #   >> "lj".mb_chars.upcase.to_s
+  #   # => "LJ"
+  #
+  # NOTE: Ruby 2.4 and later support native Unicode case mappings:
+  #
+  #   >> "lj".upcase
+  #   # => "LJ"
+  #
+  # == \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 ActiveSupport::Multibyte::Chars. For
+  # information about how to change the default Multibyte behavior see ActiveSupport::Multibyte.
+  def mb_chars
+    ActiveSupport.deprecator.warn(
+      "String#mb_chars is deprecated and will be removed in Rails 8.2. " \
+      "Use normal string methods instead."
+    )
+
+    if ActiveSupport::Multibyte.proxy_class == ActiveSupport::Multibyte::Chars
+      ActiveSupport::Multibyte::Chars.new(self, deprecation: false)
+    else
+      ActiveSupport::Multibyte.proxy_class.new(self)
+    end
+  end
+
+  # Returns +true+ if string has utf_8 encoding.
+  #
+  #   utf_8_str = "some string".encode "UTF-8"
+  #   iso_str = "some string".encode "ISO-8859-1"
+  #
+  #   utf_8_str.is_utf8? # => true
+  #   iso_str.is_utf8?   # => false
+  def is_utf8?
+    case encoding
+    when Encoding::UTF_8, Encoding::US_ASCII
+      valid_encoding?
+    when Encoding::ASCII_8BIT
+      dup.force_encoding(Encoding::UTF_8).valid_encoding?
+    else
+      false
+    end
+  end
+end

data/lib/active_support/core_ext/string/output_safety.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/erb/util"
+require "active_support/multibyte/unicode"
+
+class Object
+  def html_safe?
+    false
+  end
+end
+
+class Numeric
+  def html_safe?
+    true
+  end
+end
+
+module ActiveSupport # :nodoc:
+  class SafeBuffer < String
+    UNSAFE_STRING_METHODS = %w(
+      capitalize chomp chop delete delete_prefix delete_suffix
+      downcase lstrip next reverse rstrip scrub squeeze strip
+      succ swapcase tr tr_s unicode_normalize upcase
+    )
+
+    UNSAFE_STRING_METHODS_WITH_BACKREF = %w(gsub sub)
+
+    alias_method :original_concat, :concat
+    private :original_concat
+
+    # Raised when ActiveSupport::SafeBuffer#safe_concat is called on unsafe buffers.
+    class SafeConcatError < StandardError
+      def initialize
+        super "Could not concatenate to the buffer because it is not HTML safe."
+      end
+    end
+
+    def [](*args)
+      if html_safe?
+        new_string = super
+
+        return unless new_string
+
+        string_into_safe_buffer(new_string, true)
+      else
+        to_str[*args]
+      end
+    end
+    alias_method :slice, :[]
+
+    def slice!(*args)
+      new_string = super
+
+      return new_string if !html_safe? || new_string.nil?
+
+      string_into_safe_buffer(new_string, true)
+    end
+
+    def chr
+      return super unless html_safe?
+
+      string_into_safe_buffer(super, true)
+    end
+
+    def safe_concat(value)
+      raise SafeConcatError unless html_safe?
+      original_concat(value)
+    end
+
+    def initialize(_str = "")
+      super
+    end
+
+    def initialize_copy(other)
+      super
+      @html_unsafe = true unless other.html_safe?
+    end
+
+    def concat(value)
+      unless value.nil?
+        super(implicit_html_escape_interpolated_argument(value))
+      end
+      self
+    end
+    alias << concat
+
+    def bytesplice(*args, value)
+      super(*args, implicit_html_escape_interpolated_argument(value))
+    end
+
+    def insert(index, value)
+      super(index, implicit_html_escape_interpolated_argument(value))
+    end
+
+    def prepend(value)
+      super(implicit_html_escape_interpolated_argument(value))
+    end
+
+    def replace(value)
+      super(implicit_html_escape_interpolated_argument(value))
+    end
+
+    def []=(arg1, arg2, arg3 = nil)
+      if arg3
+        super(arg1, arg2, implicit_html_escape_interpolated_argument(arg3))
+      else
+        super(arg1, implicit_html_escape_interpolated_argument(arg2))
+      end
+    end
+
+    def +(other)
+      dup.concat(other)
+    end
+
+    def *(_)
+      new_string = super
+      new_safe_buffer = new_string.is_a?(SafeBuffer) ? new_string : SafeBuffer.new(new_string)
+      if @html_unsafe
+        new_safe_buffer.instance_variable_set(:@html_unsafe, true)
+      end
+      new_safe_buffer
+    end
+
+    def %(args)
+      case args
+      when Hash
+        escaped_args = args.transform_values { |arg| explicit_html_escape_interpolated_argument(arg) }
+      else
+        escaped_args = Array(args).map { |arg| explicit_html_escape_interpolated_argument(arg) }
+      end
+
+      self.class.new(super(escaped_args))
+    end
+
+    def html_safe?
+      @html_unsafe.nil?
+    end
+
+    def to_s
+      self
+    end
+
+    def as_json(*)
+      to_str
+    end
+
+    def to_param
+      to_str
+    end
+
+    def encode_with(coder)
+      coder.represent_object nil, to_str
+    end
+
+    UNSAFE_STRING_METHODS.each do |unsafe_method|
+      if unsafe_method.respond_to?(unsafe_method)
+        class_eval <<-EOT, __FILE__, __LINE__ + 1
+          def #{unsafe_method}(*args, &block)       # def capitalize(*args, &block)
+            to_str.#{unsafe_method}(*args, &block)  #   to_str.capitalize(*args, &block)
+          end                                       # end
+
+          def #{unsafe_method}!(*args)              # def capitalize!(*args)
+            @html_unsafe = true                     #   @html_unsafe = true
+            super                                   #   super
+          end                                       # end
+        EOT
+      end
+    end
+
+    UNSAFE_STRING_METHODS_WITH_BACKREF.each do |unsafe_method|
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{unsafe_method}(*args, &block)             # def gsub(*args, &block)
+          if block                                      #   if block
+            to_str.#{unsafe_method}(*args) { |*params|  #     to_str.gsub(*args) { |*params|
+              set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
+              block.call(*params)                       #       block.call(*params)
+            }                                           #     }
+          else                                          #   else
+            to_str.#{unsafe_method}(*args)              #     to_str.gsub(*args)
+          end                                           #   end
+        end                                             # end
+
+        def #{unsafe_method}!(*args, &block)            # def gsub!(*args, &block)
+          @html_unsafe = true                           #   @html_unsafe = true
+          if block                                      #   if block
+            super(*args) { |*params|                    #     super(*args) { |*params|
+              set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
+              block.call(*params)                       #       block.call(*params)
+            }                                           #     }
+          else                                          #   else
+            super                                       #     super
+          end                                           #   end
+        end                                             # end
+      EOT
+    end
+
+    private
+      def explicit_html_escape_interpolated_argument(arg)
+        (!html_safe? || arg.html_safe?) ? arg : ERB::Util.unwrapped_html_escape(arg)
+      end
+
+      def implicit_html_escape_interpolated_argument(arg)
+        if !html_safe? || arg.html_safe?
+          arg
+        else
+          ERB::Util.unwrapped_html_escape(arg.to_str)
+        end
+      end
+
+      def set_block_back_references(block, match_data)
+        block.binding.eval("proc { |m| $~ = m }").call(match_data)
+      rescue ArgumentError
+        # Can't create binding from C level Proc
+      end
+
+      def string_into_safe_buffer(new_string, is_html_safe)
+        new_safe_buffer = new_string.is_a?(SafeBuffer) ? new_string : SafeBuffer.new(new_string)
+        unless is_html_safe
+          new_safe_buffer.instance_variable_set :@html_unsafe, true
+        end
+        new_safe_buffer
+      end
+  end
+end
+
+class String
+  # Marks a string as trusted safe. It will be inserted into HTML with no
+  # additional escaping performed. It is your responsibility to ensure that the
+  # string contains no malicious content. This method is equivalent to the
+  # +raw+ helper in views. It is recommended that you use +sanitize+ instead of
+  # this method. It should never be called on user input.
+  def html_safe
+    ActiveSupport::SafeBuffer.new(self)
+  end
+end

data/lib/active_support/core_ext/string/starts_ends_with.rb

@@ -1,20 +1,6 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module String #:nodoc:
-      # Additional string tests.
-      module StartsEndsWith
-        # Does the string start with the specified +prefix+?
-        def starts_with?(prefix)
-          prefix = prefix.to_s
-          self[0, prefix.length] == prefix
-        end
+# frozen_string_literal: true
 
-        # Does the string end with the specified +suffix+?
-        def ends_with?(suffix)
-          suffix = suffix.to_s
-          self[-suffix.length, suffix.length] == suffix      
-        end
-      end
-    end
-  end
+class String
+  alias :starts_with? :start_with?
+  alias :ends_with? :end_with?
 end

data/lib/active_support/core_ext/string/strip.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class String
+  # Strips indentation in heredocs.
+  #
+  # For example in
+  #
+  #   if options[:usage]
+  #     puts <<-USAGE.strip_heredoc
+  #       This command does such and such.
+  #
+  #       Supported options are:
+  #         -h         This message
+  #         ...
+  #     USAGE
+  #   end
+  #
+  # the user would see the usage message aligned against the left margin.
+  #
+  # Technically, it looks for the least indented non-empty line
+  # in the whole string, and removes that amount of leading whitespace.
+  def strip_heredoc
+    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "").tap do |stripped|
+      stripped.freeze if frozen?
+    end
+  end
+end

data/lib/active_support/core_ext/string/zones.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/conversions"
+require "active_support/core_ext/time/zones"
+
+class String
+  # Converts String to a TimeWithZone in the current zone if Time.zone or Time.zone_default
+  # is set, otherwise converts String to a Time via String#to_time
+  def in_time_zone(zone = ::Time.zone)
+    if zone
+      ::Time.find_zone!(zone).parse(self)
+    else
+      to_time
+    end
+  end
+end

data/lib/active_support/core_ext/string.rb

@@ -1,11 +1,15 @@
-require File.dirname(__FILE__) + '/string/inflections'
-require File.dirname(__FILE__) + '/string/conversions'
-require File.dirname(__FILE__) + '/string/access'
-require File.dirname(__FILE__) + '/string/starts_ends_with'
+# frozen_string_literal: true
 
-class String #:nodoc:
-  include ActiveSupport::CoreExtensions::String::Access
-  include ActiveSupport::CoreExtensions::String::Conversions
-  include ActiveSupport::CoreExtensions::String::Inflections
-  include ActiveSupport::CoreExtensions::String::StartsEndsWith
-end
+require_relative "string/conversions"
+require_relative "string/filters"
+require_relative "string/multibyte"
+require_relative "string/starts_ends_with"
+require_relative "string/inflections"
+require_relative "string/access"
+require_relative "string/behavior"
+require_relative "string/output_safety"
+require_relative "string/exclude"
+require_relative "string/strip"
+require_relative "string/inquiry"
+require_relative "string/indent"
+require_relative "string/zones"

data/lib/active_support/core_ext/symbol/starts_ends_with.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Symbol
+  alias :starts_with? :start_with?
+  alias :ends_with? :end_with?
+end

data/lib/active_support/core_ext/symbol.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "symbol/starts_ends_with"

data/lib/active_support/core_ext/thread/backtrace/location.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Thread::Backtrace::Location # :nodoc:
+  def spot(ex)
+    ErrorHighlight.spot(ex, backtrace_location: self)
+  end
+end

data/lib/active_support/core_ext/time/acts_like.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/acts_like"
+
+class Time
+  # Duck-types as a Time-like class. See Object#acts_like?.
+  def acts_like_time?
+    true
+  end
+end