activesupport 3.2.22.5 → 4.0.0

data/lib/active_support/inflector/methods.rb

@@ -1,57 +1,71 @@
+# encoding: utf-8
+
 require 'active_support/inflector/inflections'
 require 'active_support/inflections'
 
 module ActiveSupport
-  # The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without,
-  # and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept
-  # in inflections.rb.
+  # The Inflector transforms words from singular to plural, class names to table
+  # names, modularized class names to ones without, and class names to foreign
+  # keys. The default inflections for pluralization, singularization, and
+  # uncountable words are kept in inflections.rb.
   #
-  # The Rails core team has stated patches for the inflections library will not be accepted
-  # in order to avoid breaking legacy applications which may be relying on errant inflections.
-  # If you discover an incorrect inflection and require it for your application, you'll need
-  # to correct it yourself (explained below).
+  # The Rails core team has stated patches for the inflections library will not
+  # be accepted in order to avoid breaking legacy applications which may be
+  # relying on errant inflections. If you discover an incorrect inflection and
+  # require it for your application or wish to define rules for languages other
+  # than English, please correct or add them yourself (explained below).
   module Inflector
     extend self
 
     # Returns the plural form of the word in the string.
     #
-    # Examples:
-    #   "post".pluralize             # => "posts"
-    #   "octopus".pluralize          # => "octopi"
-    #   "sheep".pluralize            # => "sheep"
-    #   "words".pluralize            # => "words"
-    #   "CamelOctopus".pluralize     # => "CamelOctopi"
-    def pluralize(word)
-      apply_inflections(word, inflections.plurals)
+    # If passed an optional +locale+ parameter, the word will be
+    # pluralized using rules defined for that language. By default,
+    # this parameter is set to <tt>:en</tt>.
+    #
+    #   'post'.pluralize             # => "posts"
+    #   'octopus'.pluralize          # => "octopi"
+    #   'sheep'.pluralize            # => "sheep"
+    #   'words'.pluralize            # => "words"
+    #   'CamelOctopus'.pluralize     # => "CamelOctopi"
+    #   'ley'.pluralize(:es)         # => "leyes"
+    def pluralize(word, locale = :en)
+      apply_inflections(word, inflections(locale).plurals)
     end
 
-    # The reverse of +pluralize+, returns the singular form of a word in a string.
-    #
-    # Examples:
-    #   "posts".singularize            # => "post"
-    #   "octopi".singularize           # => "octopus"
-    #   "sheep".singularize            # => "sheep"
-    #   "word".singularize             # => "word"
-    #   "CamelOctopi".singularize      # => "CamelOctopus"
-    def singularize(word)
-      apply_inflections(word, inflections.singulars)
+    # The reverse of +pluralize+, returns the singular form of a word in a
+    # string.
+    #
+    # If passed an optional +locale+ parameter, the word will be
+    # pluralized using rules defined for that language. By default,
+    # this parameter is set to <tt>:en</tt>.
+    #
+    #   'posts'.singularize            # => "post"
+    #   'octopi'.singularize           # => "octopus"
+    #   'sheep'.singularize            # => "sheep"
+    #   'word'.singularize             # => "word"
+    #   'CamelOctopi'.singularize      # => "CamelOctopus"
+    #   'leyes'.singularize(:es)       # => "ley"
+    def singularize(word, locale = :en)
+      apply_inflections(word, inflections(locale).singulars)
     end
 
-    # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
-    # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+    # 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.
+    # +camelize+ will also convert '/' to '::' which is useful for converting
+    # paths to namespaces.
     #
-    # Examples:
-    #   "active_model".camelize                # => "ActiveModel"
-    #   "active_model".camelize(:lower)        # => "activeModel"
-    #   "active_model/errors".camelize         # => "ActiveModel::Errors"
-    #   "active_model/errors".camelize(:lower) # => "activeModel::Errors"
+    #   'active_model'.camelize                # => "ActiveModel"
+    #   'active_model'.camelize(:lower)        # => "activeModel"
+    #   'active_model/errors'.camelize         # => "ActiveModel::Errors"
+    #   'active_model/errors'.camelize(:lower) # => "activeModel::Errors"
     #
-    # As a rule of thumb you can think of +camelize+ as the inverse of +underscore+,
-    # though there are cases where that does not hold:
+    # As a rule of thumb you can think of +camelize+ as the inverse of
+    # +underscore+, though there are cases where that does not hold:
     #
-    #   "SSLError".underscore.camelize # => "SslError"
+    #   'SSLError'.underscore.camelize # => "SslError"
     def camelize(term, uppercase_first_letter = true)
       string = term.to_s
       if uppercase_first_letter
@@ -66,17 +80,16 @@ module ActiveSupport
     #
     # Changes '::' to '/' to convert namespaces to paths.
     #
-    # Examples:
-    #   "ActiveModel".underscore         # => "active_model"
-    #   "ActiveModel::Errors".underscore # => "active_model/errors"
+    #   'ActiveModel'.underscore         # => "active_model"
+    #   'ActiveModel::Errors'.underscore # => "active_model/errors"
     #
-    # As a rule of thumb you can think of +underscore+ as the inverse of +camelize+,
-    # though there are cases where that does not hold:
+    # As a rule of thumb you can think of +underscore+ as the inverse of
+    # +camelize+, though there are cases where that does not hold:
     #
-    #   "SSLError".underscore.camelize # => "SslError"
+    #   'SSLError'.underscore.camelize # => "SslError"
     def underscore(camel_cased_word)
       word = camel_cased_word.to_s.dup
-      word.gsub!(/::/, '/')
+      word.gsub!('::', '/')
       word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
       word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
       word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
@@ -86,57 +99,55 @@ module ActiveSupport
     end
 
     # Capitalizes the first word and turns underscores into spaces and strips a
-    # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output.
+    # trailing "_id", if any. Like +titleize+, this is meant for creating pretty
+    # output.
     #
-    # Examples:
-    #   "employee_salary" # => "Employee salary"
-    #   "author_id"       # => "Author"
+    #   'employee_salary'.humanize # => "Employee salary"
+    #   'author_id'.humanize       # => "Author"
     def humanize(lower_case_and_underscored_word)
       result = lower_case_and_underscored_word.to_s.dup
-      inflections.humans.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+      inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
       result.gsub!(/_id$/, "")
-      result.gsub!(/_/, ' ')
+      result.tr!('_', ' ')
       result.gsub(/([a-z\d]*)/i) { |match|
         "#{inflections.acronyms[match] || match.downcase}"
       }.gsub(/^\w/) { $&.upcase }
     end
 
-    # 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.
+    # 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 as +titlecase+.
+    # +titleize+ is also aliased as +titlecase+.
     #
-    # Examples:
-    #   "man from the boondocks".titleize   # => "Man From The Boondocks"
-    #   "x-men: the last stand".titleize    # => "X Men: The Last Stand"
-    #   "TheManWithoutAPast".titleize       # => "The Man Without A Past"
-    #   "raiders_of_the_lost_ark".titleize  # => "Raiders Of The Lost Ark"
+    #   'man from the boondocks'.titleize   # => "Man From The Boondocks"
+    #   'x-men: the last stand'.titleize    # => "X Men: The Last Stand"
+    #   'TheManWithoutAPast'.titleize       # => "The Man Without A Past"
+    #   'raiders_of_the_lost_ark'.titleize  # => "Raiders Of The Lost Ark"
     def titleize(word)
-      humanize(underscore(word)).gsub(/\b('?[a-z])/) { $1.capitalize }
+      humanize(underscore(word)).gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
     end
 
-    # Create 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.
+    # Create 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.
     #
-    # Examples
-    #   "RawScaledScorer".tableize # => "raw_scaled_scorers"
-    #   "egg_and_ham".tableize     # => "egg_and_hams"
-    #   "fancyCategory".tableize   # => "fancy_categories"
+    #   'RawScaledScorer'.tableize # => "raw_scaled_scorers"
+    #   'egg_and_ham'.tableize     # => "egg_and_hams"
+    #   'fancyCategory'.tableize   # => "fancy_categories"
     def tableize(class_name)
       pluralize(underscore(class_name))
     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+.)
+    # 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+).
     #
-    # Examples:
-    #   "egg_and_hams".classify # => "EggAndHam"
-    #   "posts".classify        # => "Post"
+    #   'egg_and_hams'.classify # => "EggAndHam"
+    #   'posts'.classify        # => "Post"
     #
     # Singular names are not handled correctly:
-    #   "business".classify     # => "Busines"
+    #
+    #   'business'.classify     # => "Busines"
     def classify(table_name)
       # strip out any leading schema name
       camelize(singularize(table_name.to_s.sub(/.*\./, '')))
@@ -144,16 +155,15 @@ module ActiveSupport
 
     # Replaces underscores with dashes in the string.
     #
-    # Example:
-    #   "puni_puni" # => "puni-puni"
+    #   'puni_puni'.dasherize # => "puni-puni"
     def dasherize(underscored_word)
-      underscored_word.gsub(/_/, '-')
+      underscored_word.tr('_', '-')
     end
 
-    # Removes the module part from the expression in the string:
+    # Removes the module part from the expression in the string.
     #
-    #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
-    #   "Inflections".demodulize                                       # => "Inflections"
+    #   'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
+    #   'Inflections'.demodulize                                       # => "Inflections"
     #
     # See also +deconstantize+.
     def demodulize(path)
@@ -165,13 +175,13 @@ module ActiveSupport
       end
     end
 
-    # Removes the rightmost segment from the constant expression in the string:
+    # Removes the rightmost segment from the constant expression in the string.
     #
-    #   "Net::HTTP".deconstantize   # => "Net"
-    #   "::Net::HTTP".deconstantize # => "::Net"
-    #   "String".deconstantize      # => ""
-    #   "::String".deconstantize    # => ""
-    #   "".deconstantize            # => ""
+    #   'Net::HTTP'.deconstantize   # => "Net"
+    #   '::Net::HTTP'.deconstantize # => "::Net"
+    #   'String'.deconstantize      # => ""
+    #   '::String'.deconstantize    # => ""
+    #   ''.deconstantize            # => ""
     #
     # See also +demodulize+.
     def deconstantize(path)
@@ -182,94 +192,115 @@ module ActiveSupport
     # +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"
+    #   'Message'.foreign_key        # => "message_id"
+    #   'Message'.foreign_key(false) # => "messageid"
+    #   'Admin::Post'.foreign_key    # => "post_id"
     def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
       underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
     end
 
-    # Ruby 1.9 introduces an inherit argument for Module#const_get and
-    # #const_defined? and changes their default behavior.
-    if Module.method(:const_get).arity == 1
-      # Tries to find a constant with the name specified in the argument string:
-      #
-      #   "Module".constantize     # => Module
-      #   "Test::Unit".constantize # => Test::Unit
-      #
-      # The name is assumed to be the one of a top-level constant, no matter whether
-      # it starts with "::" or not. No lexical context is taken into account:
-      #
-      #   C = 'outside'
-      #   module M
-      #     C = 'inside'
-      #     C               # => 'inside'
-      #     "C".constantize # => 'outside', same as ::C
-      #   end
-      #
-      # NameError is raised when the name is not in CamelCase or the constant is
-      # unknown.
-      def constantize(camel_cased_word)
-        names = camel_cased_word.split('::')
-        names.shift if names.empty? || names.first.empty?
+    # Tries to find a constant with the name specified in the argument string.
+    #
+    #   'Module'.constantize     # => Module
+    #   'Test::Unit'.constantize # => Test::Unit
+    #
+    # The name is assumed to be the one of a top-level constant, no matter
+    # whether it starts with "::" or not. No lexical context is taken into
+    # account:
+    #
+    #   C = 'outside'
+    #   module M
+    #     C = 'inside'
+    #     C               # => 'inside'
+    #     'C'.constantize # => 'outside', same as ::C
+    #   end
+    #
+    # NameError is raised when the name is not in CamelCase or the constant is
+    # unknown.
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
 
-        constant = Object
-        names.each do |name|
-          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-        end
-        constant
-      end
-    else
-      def constantize(camel_cased_word) #:nodoc:
-        names = camel_cased_word.split('::')
-        names.shift if names.empty? || names.first.empty?
+          # Go down the ancestors to check it it's owned
+          # directly before we reach Object or the end of ancestors.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
 
-        constant = Object
-        names.each do |name|
-          constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
+          # owner is in Object, so raise
+          constant.const_get(name, false)
         end
-        constant
       end
     end
 
-    # Tries to find a constant with the name specified in the argument string:
+    # Tries to find a constant with the name specified in the argument string.
     #
-    #   "Module".safe_constantize     # => Module
-    #   "Test::Unit".safe_constantize # => Test::Unit
+    #   'Module'.safe_constantize     # => Module
+    #   'Test::Unit'.safe_constantize # => Test::Unit
     #
-    # The name is assumed to be the one of a top-level constant, no matter whether
-    # it starts with "::" or not. No lexical context is taken into account:
+    # The name is assumed to be the one of a top-level constant, no matter
+    # whether it starts with "::" or not. No lexical context is taken into
+    # account:
     #
     #   C = 'outside'
     #   module M
     #     C = 'inside'
     #     C                    # => 'inside'
-    #     "C".safe_constantize # => 'outside', same as ::C
+    #     'C'.safe_constantize # => 'outside', same as ::C
     #   end
     #
-    # nil is returned when the name is not in CamelCase or the constant (or part of it) is
-    # unknown.
-    #
-    #   "blargle".safe_constantize  # => nil
-    #   "UnknownModule".safe_constantize  # => nil
-    #   "UnknownModule::Foo::Bar".safe_constantize  # => nil
+    # +nil+ is returned when the name is not in CamelCase or the constant (or
+    # part of it) is unknown.
     #
+    #   'blargle'.safe_constantize  # => nil
+    #   'UnknownModule'.safe_constantize  # => nil
+    #   'UnknownModule::Foo::Bar'.safe_constantize  # => nil
     def safe_constantize(camel_cased_word)
-      begin
-        constantize(camel_cased_word)
-      rescue NameError => e
-        raise unless e.message =~ /(uninitialized constant|wrong constant name) #{const_regexp(camel_cased_word)}$/ ||
-          e.name.to_s == camel_cased_word.to_s
-      rescue ArgumentError => e
-        raise unless e.message =~ /not missing constant #{const_regexp(camel_cased_word)}\!$/
+      constantize(camel_cased_word)
+    rescue NameError => e
+      raise unless e.message =~ /(uninitialized constant|wrong constant name) #{const_regexp(camel_cased_word)}$/ ||
+        e.name.to_s == camel_cased_word.to_s
+    rescue ArgumentError => e
+      raise unless e.message =~ /not missing constant #{const_regexp(camel_cased_word)}\!$/
+    end
+
+    # Returns the suffix that should be added to a number to denote the position
+    # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+    #
+    #   ordinal(1)     # => "st"
+    #   ordinal(2)     # => "nd"
+    #   ordinal(1002)  # => "nd"
+    #   ordinal(1003)  # => "rd"
+    #   ordinal(-11)   # => "th"
+    #   ordinal(-1021) # => "st"
+    def ordinal(number)
+      abs_number = number.to_i.abs
+
+      if (11..13).include?(abs_number % 100)
+        "th"
+      else
+        case abs_number % 10
+          when 1; "st"
+          when 2; "nd"
+          when 3; "rd"
+          else    "th"
+        end
       end
     end
 
     # Turns a number into an ordinal string used to denote the position in an
     # ordered sequence such as 1st, 2nd, 3rd, 4th.
     #
-    # Examples:
     #   ordinalize(1)     # => "1st"
     #   ordinalize(2)     # => "2nd"
     #   ordinalize(1002)  # => "1002nd"
@@ -277,16 +308,7 @@ module ActiveSupport
     #   ordinalize(-11)   # => "-11th"
     #   ordinalize(-1021) # => "-1021st"
     def ordinalize(number)
-      if (11..13).include?(number.to_i.abs % 100)
-        "#{number}th"
-      else
-        case number.to_i.abs % 10
-          when 1; "#{number}st"
-          when 2; "#{number}nd"
-          when 3; "#{number}rd"
-          else    "#{number}th"
-        end
-      end
+      "#{number}#{ordinal(number)}"
     end
 
     private
@@ -304,16 +326,15 @@ module ActiveSupport
 
     # Applies inflection rules for +singularize+ and +pluralize+.
     #
-    # Examples:
-    #  apply_inflections("post", inflections.plurals) # => "posts"
-    #  apply_inflections("posts", inflections.singulars) # => "post"
+    #  apply_inflections('post', inflections.plurals)    # => "posts"
+    #  apply_inflections('posts', inflections.singulars) # => "post"
     def apply_inflections(word, rules)
       result = word.to_s.dup
 
-      if word.empty? || inflections.uncountables.any? { |inflection| result =~ /\b#{inflection}\Z/i }
+      if word.empty? || inflections.uncountables.include?(result.downcase[/\b\w+\Z/])
         result
       else
-        rules.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+        rules.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
         result
       end
     end

data/lib/active_support/inflector/transliterate.rb

@@ -8,7 +8,7 @@ module ActiveSupport
     # Replaces non-ASCII characters with an ASCII approximation, or if none
     # exists, a replacement character which defaults to "?".
     #
-    #    transliterate("Ærøskøbing")
+    #    transliterate('Ærøskøbing')
     #    # => "AEroskobing"
     #
     # Default approximations are provided for Western/Latin characters,
@@ -30,33 +30,33 @@ module ActiveSupport
     #         ö: "oe"
     #
     #   # Or set them using Ruby
-    #   I18n.backend.store_translations(:de, :i18n => {
-    #     :transliterate => {
-    #       :rule => {
-    #         "ü" => "ue",
-    #         "ö" => "oe"
+    #   I18n.backend.store_translations(:de, i18n: {
+    #     transliterate: {
+    #       rule: {
+    #         'ü' => 'ue',
+    #         'ö' => 'oe'
     #       }
     #     }
     #   })
     #
-    # The value for <tt>i18n.transliterate.rule</tt> can be a simple Hash that maps
-    # characters to ASCII approximations as shown above, or, for more complex
-    # requirements, a Proc:
+    # The value for <tt>i18n.transliterate.rule</tt> can be a simple Hash that
+    # maps characters to ASCII approximations as shown above, or, for more
+    # complex requirements, a Proc:
     #
-    #   I18n.backend.store_translations(:de, :i18n => {
-    #     :transliterate => {
-    #       :rule => lambda {|string| MyTransliterator.transliterate(string)}
+    #   I18n.backend.store_translations(:de, i18n: {
+    #     transliterate: {
+    #       rule: ->(string) { MyTransliterator.transliterate(string) }
     #     }
     #   })
     #
     # Now you can have different transliterations for each locale:
     #
     #   I18n.locale = :en
-    #   transliterate("Jürgen")
+    #   transliterate('Jürgen')
     #   # => "Jurgen"
     #
     #   I18n.locale = :de
-    #   transliterate("Jürgen")
+    #   transliterate('Jürgen')
     #   # => "Juergen"
     def transliterate(string, replacement = "?")
       I18n.transliterate(ActiveSupport::Multibyte::Unicode.normalize(
@@ -64,9 +64,8 @@ module ActiveSupport
           :replacement => replacement)
     end
 
-    # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
-    #
-    # ==== Examples
+    # Replaces special characters in a string so that it may be used as part of
+    # a 'pretty' URL.
     #
     #   class Person
     #     def to_param

data/lib/active_support/json/decoding.rb

@@ -8,14 +8,13 @@ module ActiveSupport
 
   module JSON
     class << self
+      # Parses a JSON string (JavaScript Object Notation) into a hash.
+      # See www.json.org for more info.
+      #
+      #   ActiveSupport::JSON.decode("{\"team\":\"rails\",\"players\":\"36\"}")
+      #   => {"team" => "rails", "players" => "36"}
       def decode(json, options ={})
-        # Can't reliably detect whether MultiJson responds to load, since it's
-        # a reserved word. Use adapter as a proxy for new features.
-        data = if MultiJson.respond_to?(:adapter)
-          MultiJson.load(json, options)
-        else
-          MultiJson.decode(json, options)
-        end
+        data = MultiJson.load(json, options)
         if ActiveSupport.parse_json_times
           convert_dates_from(data)
         else
@@ -24,20 +23,12 @@ module ActiveSupport
       end
 
       def engine
-        if MultiJson.respond_to?(:adapter)
-          MultiJson.adapter
-        else
-          MultiJson.engine
-        end
+        MultiJson.adapter
       end
       alias :backend :engine
 
       def engine=(name)
-        if MultiJson.respond_to?(:use)
-          MultiJson.use name
-        else
-          MultiJson.engine = name
-        end
+        MultiJson.use(name)
       end
       alias :backend= :engine=
 
@@ -48,6 +39,16 @@ module ActiveSupport
         self.backend = old_backend
       end
 
+      # Returns the class of the error that will be raised when there is an
+      # error in decoding JSON. Using this method means you won't directly
+      # depend on the ActiveSupport's JSON implementation, in case it changes
+      # in the future.
+      #
+      #   begin
+      #     obj = ActiveSupport::JSON.decode(some_string)
+      #   rescue ActiveSupport::JSON.parse_error
+      #     Rails.logger.warn("Attempted to decode invalid JSON: #{some_string}")
+      #   end
       def parse_error
         MultiJson::DecodeError
       end