class Dry::Inflector

def camelize_lower(input)
  internal_camelize(input, false)
end

def camelize_upper(input)
  internal_camelize(input, true)
end

def classify(input)
  camelize(singularize(input.to_s.split(".").last))
end

def constantize(input)
  Object.const_get(input, false)
end

def dasherize(input)
  input.to_s.tr("_", "-")
end

def demodulize(input)
  input.to_s.split("::").last
end

def foreign_key(input)
  "#{underscore(demodulize(input))}_id"
end

def humanize(input)
  input = input.to_s
  result = inflections.humans.apply_to(input)
  result.delete_suffix!("_id")
  result.tr!("_", " ")
  match = /(\W)/.match(result)
  separator = match ? match[0] : DEFAULT_SEPARATOR
  result.split(separator).map.with_index { |word, index|
    inflections.acronyms.apply_to(word, capitalize: index.zero?)
  }.join(separator)
end

def initialize(&)
  @inflections = Inflections.build(&)
end

def internal_camelize(input, upper)
  input = input.to_s.dup
  input.sub!(/^[a-z\d]*/) { |match| inflections.acronyms.apply_to(match, capitalize: upper) }
  input.gsub!(%r{(?:[_-]|(/))([a-z\d]*)}i) do
    m1 = Regexp.last_match(1)
    m2 = Regexp.last_match(2)
    "#{m1}#{inflections.acronyms.apply_to(m2)}"
  end
  input.gsub!("/", "::")
  input
end

def ordinalize(number)
  abs_value = number.abs
  if ORDINALIZE_TH[abs_value % 100]
    "#{number}th"
  else
    case abs_value % 10
    when 1 then "#{number}st"
    when 2 then "#{number}nd"
    when 3 then "#{number}rd"
    else        "#{number}th"
    end
  end
end

def pluralize(input)
  input = input.to_s
  return input if uncountable?(input)
  inflections.plurals.apply_to(input)
end

def singularize(input)
  input = input.to_s
  return input if uncountable?(input)
  inflections.singulars.apply_to(input)
end

def tableize(input)
  input = input.to_s.gsub("::", "_")
  pluralize(underscore(input))
end

def to_s
  "#<Dry::Inflector>"
end

def uncountable?(input)
  input.match?(/\A[[:space:]]*\z/) ||
    inflections.uncountables.include?(input.downcase) ||
    inflections.uncountables.include?(input.split(/_|\b/).last.downcase)
end

def underscore(input)
  input = input.to_s.gsub("::", "/")
  input.gsub!(inflections.acronyms.regex) do
    m1 = Regexp.last_match(1)
    m2 = Regexp.last_match(2)
    "#{m1 ? "_" : ""}#{m2.downcase}"
  end
  input.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
  input.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
  input.tr!("-", "_")
  input.downcase!
  input
end