class Github::Arguments

Request arguments handler

def assert_required(required)


Check if required keys are present inside parameters hash. 
def assert_required(required)
  assert_required_keys required, params
  self
end

def assert_values(values, key=nil)


Check if parameters match expected values. 
def assert_values(values, key=nil)
  assert_valid_values values, (key.nil? ? params : params[key])
  self
end

def check_assignment!(options)


Check if required arguments have been set on instance. 
def check_assignment!(options)
  result = required.inject({}) { |hash, arg|
    if api.respond_to?(:"#{arg}") && (value = api.send(:"#{arg}"))
      hash[arg] = value
    end
    hash
  }
  assert_presence_of result
  result
end

def check_requirement!(*args)


Check if required arguments are present. 
def check_requirement!(*args)
  args_length     = args.length
  required_length = required.length
  if args_length < required_length
    ::Kernel.raise ArgumentError, "wrong number of arguments (#{args_length} for #{required_length})"
  end
end

def extract_pagination(options)


Fine auto_pagination parameter in options hash 
def extract_pagination(options)
  if (value = options.delete(AUTO_PAGINATION))
    api.auto_pagination = value
  end
end

def extract_remaining(args)


Find remaining arguments 
def extract_remaining(args)
  args[required.size..-1]
end

def initialize(api, options={})


:required - arguments that must be present before request is fired
= Parameters

Takes api, filters and required arguments 
def initialize(api, options={})
  normalize! options
  @api      = api
  @required = options.fetch('required', []).map(&:to_s)
  @optional = options.fetch('optional', []).map(&:to_s)
end

def parse(*args, &block)


Arguments can be part of parameters hash or be simple string arguments.
Parse arguments to allow for flexible api calls. 
def parse(*args, &block)
  options = args.extract_options!
  normalize! options
  if !args.size.zero?
    parse_arguments *args
  else
    # Arguments are inside the parameters hash
    parse_options options
  end
  @params = options
  @remaining = extract_remaining(args)
  extract_pagination(options)
  yield_or_eval(&block)
  self
end

def parse_arguments(*args)


Check and set all requried arguments. 
def parse_arguments(*args)
  assert_presence_of *args
  required.each_with_index do |req, indx|
    api.set req, args[indx]
  end
  check_requirement!(*args)
end

def parse_options(options)


validate their presence(if not nil or empty string).
Remove required arguments from parameters and 
def parse_options(options)
  options.each { |key, val| remove_required(options, key, val) }
  provided_args = check_assignment!(options)
  check_requirement!(*provided_args.keys)
end

def remove_required(options, key, val)


Remove required argument from parameters 
def remove_required(options, key, val)
  key = key.to_s
  if required.include? key
    assert_presence_of val
    options.delete key
    api.set key, val
  end
end

def sift(keys, key=nil, options={})


:recursive - boolean that toggles whether nested filtering should be applied
= Parameters

Remove unkown keys from parameters hash. 
def sift(keys, key=nil, options={})
  filter! keys, (key.nil? ? params : params[key]), options if keys.any?
  self
end

def yield_or_eval(&block)


Evaluate block 
def yield_or_eval(&block)
  return unless block
  block.arity > 0 ? yield(self) : self.instance_eval(&block)
end