module Graphlyte::Schema::ParserHelpers

Public Instance Methods

advance(offset = 1) click to toggle source
# File lib/graphlyte/schema/parser.rb, line 142
def advance(offset = 1)
  @position += offset
end
expect(*expected_tokens) click to toggle source
# File lib/graphlyte/schema/parser.rb, line 129
def expect(*expected_tokens)
  upcoming = tokens[position, expected_tokens.size]
  if upcoming.map(&:first) == expected_tokens
    advance(expected_tokens.size)
    upcoming
  end
end
need(*required_tokens) click to toggle source
# File lib/graphlyte/schema/parser.rb, line 137
def need(*required_tokens)
  upcoming = tokens[position, required_tokens.size]
  expect(*required_tokens) or raise "Unexpected tokens. Expected #{required_tokens.inspect} but got #{upcoming.inspect}"
end
parse_arg() click to toggle source
# File lib/graphlyte/schema/parser.rb, line 61
def parse_arg
  if (token = expect(:ARG_KEY)) && (value = parse_value)
    defaults = parse_default
    key = token[0][1]
    hash = {}
    hash[key] = value
    hash
  elsif (token = expect(:SPECIAL_ARG_KEY)) && (value = parse_value)
    defaults = parse_default
    @special_args ||= {}
    arg = {}
    if [Array, Hash].include?(value.class)
      arg[token[0][1]] = value
    else
      new_val = Schema::Types::Base.new(value, token[0][1], defaults)
      arg[token[0][1]] = new_val
    end
    @special_args.merge!(arg)
    arg
  end
end
parse_arg_array() click to toggle source
# File lib/graphlyte/schema/parser.rb, line 99
def parse_arg_array
  args = repeat(:parse_value)
  need(:ARG_ARRAY_END)
  args
end
parse_arg_hash() click to toggle source
# File lib/graphlyte/schema/parser.rb, line 105
def parse_arg_hash
  if (key = expect(:ARG_KEY)) && (value = parse_value)
    hash = {}
    hash[key[0][1]] = value
    hash
    if new_hash = parse_arg_hash
      hash.merge!(new_hash)
    else
      need(:ARG_HASH_END)
      hash
    end
  end
end
parse_args() click to toggle source
# File lib/graphlyte/schema/parser.rb, line 45
def parse_args
  if expect(:START_ARGS)
    args = repeat(:parse_arg).inject(&:merge)
    need(:END_ARGS)
    args
  end
end
parse_default() click to toggle source
# File lib/graphlyte/schema/parser.rb, line 53
def parse_default
  if expect(:START_DEFAULT_VALUE)
    value = parse_value
    need(:END_DEFAULT_VALUE)
    value
  end
end
parse_field() click to toggle source
# File lib/graphlyte/schema/parser.rb, line 16
def parse_field
  alias_field = expect(:ALIAS)
  if token = expect(:FRAGMENT_REF)
    raise "Can't find fragment #{token[0][1]}" unless fragments_dictionary[token[0][1]]
    fragments_dictionary[token[0][1]]
  elsif field = expect(:FIELD_NAME)
    args = parse_args
    if fieldset = parse_fieldset
      need(:END_FIELD)
      field = Field.new(field[0][1], fieldset, args)
    else
      field = Field.new(field[0][1], Fieldset.empty, args)
    end

    if alias_field
      field.alias(alias_field[0][1])
    end

    field
  end
end
parse_fields() click to toggle source
# File lib/graphlyte/schema/parser.rb, line 11
def parse_fields
  fields = repeat(:parse_field)
  fields
end
parse_fieldset() click to toggle source
# File lib/graphlyte/schema/parser.rb, line 38
def parse_fieldset
  if expect(:START_FIELD)
    fields = parse_fields
    Fieldset.new(builder: Builder.new(fields))
  end
end
parse_value() click to toggle source
# File lib/graphlyte/schema/parser.rb, line 83
def parse_value
  if token = expect(:ARG_NUM_VALUE) || expect(:ARG_STRING_VALUE) || expect(:ARG_BOOL_VALUE) || expect(:ARG_FLOAT_VALUE)
    token[0][1]
  elsif token = expect(:SPECIAL_ARG_REF)
    ref = token[0][1]
    raise "Can't find ref $#{ref}" unless @special_args[ref]
    @special_args[ref]
  elsif token = expect(:SPECIAL_ARG_VAL)
    token[0][1]
  elsif token = expect(:ARG_HASH_START)
    parse_arg_hash
  elsif expect(:ARG_ARRAY_START)
    parse_arg_array
  end
end
repeat(method) click to toggle source
# File lib/graphlyte/schema/parser.rb, line 119
def repeat(method)
  results = []

  while result = send(method)
    results << result
  end

  results
end
sort_fragments(sorted = [], fragments) click to toggle source
# File lib/graphlyte/schema/parser.rb, line 146
def sort_fragments(sorted = [], fragments)
  return sorted if !fragments || fragments.empty?
  fragment_tokens = fragments.shift

  current_ref = fragment_tokens.find do |token|
    token[0] == :FRAGMENT_REF
  end

  if current_ref
    exists = sorted.any? do |frags|
      frags.find do |el|
        el[0] == :START_FRAGMENT && el[1] == current_ref[1]
      end
    end
    if exists
      sorted << fragment_tokens
      sort_fragments(sorted, fragments)
    else
      fragments.push fragment_tokens
      sort_fragments(sorted, fragments)
    end
  else
    sorted << fragment_tokens
    sort_fragments(sorted, fragments)
  end
end
take_fragments() click to toggle source
# File lib/graphlyte/schema/parser.rb, line 173
def take_fragments
  aggregate = @tokens.inject({taking: false, idx: 0,  fragments: []}) do |memo, token_arr|
    if token_arr[0] == :END_FRAGMENT
      memo[:fragments][memo[:idx]] << token_arr
      memo[:taking] = false
      memo[:idx] += 1
    elsif token_arr[0] === :START_FRAGMENT
      memo[:fragments][memo[:idx]] = [token_arr]
      memo[:taking] = true
    elsif memo[:taking]
      memo[:fragments][memo[:idx]] << token_arr
    end
    memo
  end
  aggregate[:fragments]
end