class BinData::AcceptedParametersPlugin::AcceptedParameters

def all
  (@mandatory + @optional + @default.keys).uniq
end

def default(args = nil)
  if args
    to_syms(args.keys)  # call for side effect of validating names
    args.each_pair do |param, value|
      @default[param.to_sym] = value
    end
  end
  @default
end

def ensure_valid_names(names)
  invalid_names = self.class.invalid_parameter_names
  names.each do |name|
    if invalid_names.include?(name)
      raise NameError.new("Rename parameter '#{name}' " \
                          "as it shadows an existing method.", name)
    end
  end
end

def initialize(ancestor_parameters = nil)
  if ancestor_parameters
    @mandatory = ancestor_parameters.mandatory.dup
    @optional  = ancestor_parameters.optional.dup
    @default   = ancestor_parameters.default.dup
    @mutually_exclusive = ancestor_parameters.mutually_exclusive.dup
  else
    @mandatory = []
    @optional  = []
    @default   = Hash.new
    @mutually_exclusive = []
  end
end

def invalid_parameter_names
  @invalid_parameter_names ||= begin
    all_names = LazyEvaluator.instance_methods(true)
    allowed_names = [:name, :type]
    invalid_names = (all_names - allowed_names).uniq
    Hash[*invalid_names.collect { |key| [key.to_sym, true] }.flatten]
  end
end

def mandatory(*args)
  unless args.empty?
    @mandatory.concat(to_syms(args))
    @mandatory.uniq!
  end
  @mandatory
end

def mutually_exclusive(*args)
  arg1 = args.shift
  until args.empty?
    args.each do |arg2|
      @mutually_exclusive.push([arg1.to_sym, arg2.to_sym])
      @mutually_exclusive.uniq!
    end
    arg1 = args.shift
  end
  @mutually_exclusive
end

def optional(*args)
  unless args.empty?
    @optional.concat(to_syms(args))
    @optional.uniq!
  end
  @optional
end

def to_syms(args)
  syms = args.collect(&:to_sym)
  ensure_valid_names(syms)
  syms
end