# -*- coding: utf-8 -*-
module Yaks
  module Util
    extend self
    extend Forwardable

    def_delegators Inflection, :singular, :singularize, :pluralize

    def underscore(str)
      str.gsub(/::/, '/')
        .gsub(/(?<!^|\/)([A-Z])(?=[a-z$])|(?<=[a-z])([A-Z])/, '_\1\2')
        .tr("-", "_")
        .downcase
    end

    def camelize(str)
      str.gsub(/\/(.?)/)     { "::#{ $1.upcase }" }
        .gsub!(/(?:^|_)(.)/) { $1.upcase          }
    end

    def List(*args)
      Hamster.list(*args)
    end

    def Hash(*args)
      Hamster.hash(*args)
    end

    def Set(*args)
      Hamster.set(*args)
    end

    # Turn what is maybe a Proc into its result (or itself)
    #
    # When input can be either a value or a proc that returns a value,
    # this conversion function can be used to resolve the thing to a
    # value.
    #
    # The proc can be evaluated (instance_evaled) in a certain context,
    # or evaluated as a closure.
    #
    # @param [Object|Proc] maybe_proc
    #   A proc or a plain value
    # @param [Object] context
    #   (optional) A context used to instance_eval the proc
    def Resolve(maybe_proc, context = nil)
      if maybe_proc.respond_to?(:to_proc)
        if context
          if maybe_proc.to_proc.arity > 0
            context.instance_eval(&maybe_proc)
          else
            # In case it's a lambda with zero arity instance_eval fails
            context.instance_exec(&maybe_proc)
          end
        else
          maybe_proc.()
        end
      else
        maybe_proc
      end
    end

    def curry_method(name)
      method(name).to_proc.curry
    end
    alias μ curry_method

    def identity_function
      ->(x) {x}
    end
    alias ι identity_function

    def juxt(*procs)
      ->(*args) { procs.map &σ(:call, *args) }
    end

    def curry_symbol(symbol, *args, &blk)
      ->(obj) { obj.method(symbol).to_proc.curry.(*args, &blk) }
    end
    alias σ curry_symbol
    alias send_with_args curry_symbol

    def extract_options(args)
      if args.last.is_a? Hash
        [args.take(args.count-1), args.last]
      else
        [args, {}]
      end
    end

  end
end