opal-activesupport 0.3.1 → 0.3.2

data/opal/active_support/core_ext/string/inflections.rb

@@ -1,15 +1,77 @@
 require 'active_support/inflector'
 
 class String
-  def pluralize
-    ActiveSupport::Inflector.pluralize(self)
+  def pluralize(count = nil, locale = :en)
+    locale = count if count.is_a?(Symbol)
+    if count == 1
+      dup
+    else
+      ActiveSupport::Inflector.pluralize(self, locale)
+    end
   end
 
-  def singularize
-    ActiveSupport::Inflector.singularize(self)
+  def singularize(locale = :en)
+    ActiveSupport::Inflector.singularize(self, locale)
   end
 
   def constantize
     ActiveSupport::Inflector.constantize(self)
   end
+
+  def safe_constantize
+    ActiveSupport::Inflector.safe_constantize(self)
+  end
+
+  def camelize(first_letter = :upper)
+    case first_letter
+    when :upper
+      ActiveSupport::Inflector.camelize(self, true)
+    when :lower
+      ActiveSupport::Inflector.camelize(self, false)
+    else
+      raise ArgumentError, "Invalid option, use either :upper or :lower."
+    end
+  end
+  alias_method :camelcase, :camelize
+
+  def titleize(keep_id_suffix: false)
+    ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix)
+  end
+  alias_method :titlecase, :titleize
+
+  def underscore
+    ActiveSupport::Inflector.underscore(self)
+  end
+
+  def dasherize
+    ActiveSupport::Inflector.dasherize(self)
+  end
+
+  def demodulize
+    ActiveSupport::Inflector.demodulize(self)
+  end
+
+  def deconstantize
+    ActiveSupport::Inflector.deconstantize(self)
+  end
+
+  def tableize
+    ActiveSupport::Inflector.tableize(self)
+  end
+
+  def classify
+    ActiveSupport::Inflector.classify(self)
+  end
+
+  def humanize(capitalize: true, keep_id_suffix: false)
+    ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix)
+  end
+
+  def upcase_first
+    ActiveSupport::Inflector.upcase_first(self)
+  end
+
+  def foreign_key(separate_class_name_and_id_with_underscore = true)
+    ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+  end
 end

data/opal/active_support/inflections.rb

@@ -1,3 +1,5 @@
+require "active_support/inflector/inflections"
+
 module ActiveSupport
   Inflector.inflections(:en) do |inflect|
     inflect.plural(/$/, 's')

data/opal/active_support/inflector.rb

@@ -1,2 +1,5 @@
-require 'active_support/inflector/inflections'
-require 'active_support/inflections'
+require "active_support/inflector/inflections"
+require "active_support/inflector/methods"
+
+require "active_support/inflections"
+require "active_support/core_ext/string/inflections"

data/opal/active_support/inflector/inflections.rb

@@ -4,86 +4,67 @@ module ActiveSupport
   module Inflector
     extend self
 
-    def inflections(lang = :en)
-      if block_given?
-        yield Inflections.instance
-      else
-        Inflections.instance
-      end
-    end
+    class Inflections
+      @__instance__ = {}
 
-    def constantize(camel_cased_word)
-      names = camel_cased_word.split('::')
+      class Uncountables < Array
+        def <<(*word)
+          add(word)
+        end
 
-      # Trigger a built-in NameError exception including the ill-formed constant in the message.
-      Object.const_get(camel_cased_word) if names.empty?
+        def add(words)
+          words = words.flatten.map(&:downcase)
+          concat(words)
+          self
+        end
 
-      # Remove the first blank element in case of '::ClassName' notation.
-      names.shift if names.size > 1 && names.first.empty?
+        def uncountable?(str)
+          include?(str.downcase)
+        end
 
-      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)
-
-          # Go down the ancestors to check if it is owned directly. The check
-          # stops when we reach Object or the end of ancestors tree.
-          constant = constant.ancestors.inject do |const, ancestor|
-            break const    if ancestor == Object
-            break ancestor if ancestor.const_defined?(name, false)
-            const
-          end
-
-          # owner is in Object, so raise
-          constant.const_get(name, false)
+        def dup
+          copy = Uncountables.new
+          copy.add(self)
+          copy
         end
       end
-    end
 
-    def pluralize(word)
-      apply_inflections(word, inflections.plurals)
-    end
 
-    def singularize(word)
-      apply_inflections(word, inflections.singulars)
-    end
+      def self.instance(locale)
+        @__instance__[locale] ||= new
+      end
 
-    def apply_inflections(word, rules)
-      result = word.to_s
+      attr_reader :plurals, :singulars, :uncountables, :humans
 
-      if inflections.uncountables.include?(result.downcase)
-        result
-      else
-        rules.detect do |rule, replacement|
-          break result.sub(rule, replacement) if result.index(rule)
-        end
+      def initialize
+        @plurals, @singulars, @uncountables, @humans = [], [], Uncountables.new, []
       end
-    end
 
-    class Inflections
-      def self.instance
-        @__instance__ ||= new
+      def initialize_dup(orig) # :nodoc:
+        %w(plurals singulars uncountables humans).each do |scope|
+          instance_variable_set("@#{scope}", orig.send(scope).dup)
+        end
       end
 
-      attr_reader :plurals, :singulars, :uncountables
-
-      def initialize
-        @plurals, @singulars, @uncountables = [], [], Set.new
-      end
 
       def plural(rule, replacement)
+        @uncountables.delete(rule) if rule.is_a?(String)
+        @uncountables.delete(replacement)
         @plurals.unshift([rule, replacement])
       end
 
       def singular(rule, replacement)
+        @uncountables.delete(rule) if rule.is_a?(String)
+        @uncountables.delete(replacement)
         @singulars.unshift([rule, replacement])
       end
 
-      def uncountable(words)
-        words.each { |w| @uncountables << w.downcase }
+      def uncountable(*words)
+        @uncountables.add(words)
+      end
+
+      def human(rule, replacement)
+        @humans.unshift([rule, replacement])
       end
 
       def irregular(singular, plural)
@@ -103,17 +84,34 @@ module ActiveSupport
           singular(/(#{s0})#{srest}$/i, '\1' + srest)
           singular(/(#{p0})#{prest}$/i, '\1' + srest)
         else
-          plural(/#{s0.upcase}(?i)#{srest}$/,   p0.upcase   + prest)
-          plural(/#{s0.downcase}(?i)#{srest}$/, p0.downcase + prest)
-          plural(/#{p0.upcase}(?i)#{prest}$/,   p0.upcase   + prest)
-          plural(/#{p0.downcase}(?i)#{prest}$/, p0.downcase + prest)
-
-          singular(/#{s0.upcase}(?i)#{srest}$/,   s0.upcase   + srest)
-          singular(/#{s0.downcase}(?i)#{srest}$/, s0.downcase + srest)
-          singular(/#{p0.upcase}(?i)#{prest}$/,   s0.upcase   + srest)
-          singular(/#{p0.downcase}(?i)#{prest}$/, s0.downcase + srest)
+          plural(/#{s0.upcase}#{srest}$/i,   p0.upcase   + prest)
+          plural(/#{s0.downcase}#{srest}$/i, p0.downcase + prest)
+          plural(/#{p0.upcase}#{prest}$/i,   p0.upcase   + prest)
+          plural(/#{p0.downcase}#{prest}$/i, p0.downcase + prest)
+
+          singular(/#{s0.upcase}#{srest}$/i,   s0.upcase   + srest)
+          singular(/#{s0.downcase}#{srest}$/i, s0.downcase + srest)
+          singular(/#{p0.upcase}#{prest}$/i,   s0.upcase   + srest)
+          singular(/#{p0.downcase}#{prest}$/i, s0.downcase + srest)
+        end
+      end
+
+      def clear(scope = :all)
+        case scope
+        when :all
+          @plurals, @singulars, @uncountables, @humans = [], [], Uncountables.new, []
+        else
+          instance_variable_set "@#{scope}", []
         end
       end
     end
+
+    def inflections(locale = :en)
+      if block_given?
+        yield Inflections.instance(locale)
+      else
+        Inflections.instance(locale)
+      end
+    end
   end
 end

data/opal/active_support/inflector/methods.rb

@@ -0,0 +1,198 @@
+require "active_support/inflections"
+
+module ActiveSupport
+  module Inflector
+    extend self
+
+    def pluralize(word, locale = :en)
+      apply_inflections(word, inflections(locale).plurals, locale)
+    end
+
+    def singularize(word, locale = :en)
+      apply_inflections(word, inflections(locale).singulars, locale)
+    end
+
+    def camelize(term, uppercase_first_letter = true)
+      string = term.to_s
+      if uppercase_first_letter
+        string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
+      else
+        string = string.downcase
+      end
+      string = string.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+      string = string.gsub("/".freeze, "::".freeze)
+      string
+    end
+
+    def underscore(camel_cased_word)
+      return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
+      word = camel_cased_word.to_s.gsub("::".freeze, "/".freeze)
+      word = word.gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+      word = word.gsub(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+      word = word.tr("-".freeze, "_".freeze)
+      word = word.downcase
+      word
+    end
+
+    def humanize(lower_case_and_underscored_word, capitalize: true, keep_id_suffix: false)
+      result = lower_case_and_underscored_word.to_s.dup
+
+      inflections.humans.each do |(rule, replacement)|
+        if (rule.is_a?(Regexp) && result =~ rule) || (rule.is_a?(String) && result == rule)
+          result = result.sub(rule, replacement)
+          break
+        end
+      end
+
+      result = result.sub(/\A_+/, "".freeze)
+      unless keep_id_suffix
+        result = result.sub(/_id\z/, "".freeze)
+      end
+      result = result.tr("_".freeze, " ".freeze)
+
+      result = result.gsub(/([a-z\d]*)/i) do |match|
+        "#{match.downcase}"
+      end
+
+      if capitalize
+        result = result.sub(/\A\w/) { |match| match.upcase }
+      end
+
+      result
+    end
+
+    def upcase_first(string)
+      string.length > 0 ? string[0].upcase + string[1..-1] : ""
+    end
+
+    def titleize(word, keep_id_suffix: false)
+      humanize(underscore(word), keep_id_suffix: keep_id_suffix).gsub(/([a-zA-Z'’`])[a-z]*/) do |match|
+        match.capitalize
+      end
+    end
+
+    def tableize(class_name)
+      pluralize(underscore(class_name))
+    end
+
+    def classify(table_name)
+      # strip out any leading schema name
+      camelize(singularize(table_name.to_s.sub(/.*\./, "".freeze)))
+    end
+
+    def dasherize(underscored_word)
+      underscored_word.tr("_".freeze, "-".freeze)
+    end
+
+    def demodulize(path)
+      path = path.to_s
+      if i = path.rindex("::")
+        path[(i + 2)..-1]
+      else
+        path
+      end
+    end
+
+    def deconstantize(path)
+      path.to_s[0, path.rindex("::") || 0] # implementation based on the one in facets' Module#spacename
+    end
+
+    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
+
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+
+      # Trigger a built-in NameError exception including the ill-formed constant in the message.
+      # FIXME: initially was
+      # Object.const_get(camel_cased_word) if names.empty?
+      # Changed because Opal can't handles such case
+      # Instead it throws something like <NoMethodError: undefined method 'upcase' for nil>
+      raise NameError, 'wrong constant name ' if names.empty?
+
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && 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)
+
+          # Go down the ancestors to check if it is owned directly. The check
+          # stops when we reach Object or the end of ancestors tree.
+          constant = constant.ancestors.inject(constant) do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+
+    def safe_constantize(camel_cased_word)
+      constantize(camel_cased_word)
+    rescue NameError => e
+      raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
+        e.name.to_s == camel_cased_word.to_s)
+    rescue ArgumentError => e
+      raise unless /not missing constant #{const_regexp(camel_cased_word)}!$/.match?(e.message)
+    end
+
+
+    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
+
+    def ordinalize(number)
+      "#{number}#{ordinal(number)}"
+    end
+
+    private
+
+      def const_regexp(camel_cased_word)
+        parts = camel_cased_word.split("::".freeze)
+
+        return Regexp.escape(camel_cased_word) if parts.blank?
+
+        last = parts.pop
+
+        parts.reverse.inject(last) do |acc, part|
+          part.empty? ? acc : "#{part}(::#{acc})?"
+        end
+      end
+
+      def apply_inflections(word, rules, locale = :en)
+        result = word.to_s.dup
+
+        if word.empty? || inflections(locale).uncountables.uncountable?(result)
+          result
+        else
+          rules.each do |(rule, replacement)|
+            if (rule.is_a?(Regexp) && result =~ rule) || (rule.is_a?(String) && result == rule)
+              result = result.sub(rule, replacement)
+              break
+            end
+          end
+          result
+        end
+      end
+  end
+end