Method: Puppet::Pops::Types::TypeParser#interpret_AccessExpression

Defined in:

lib/puppet/pops/types/type_parser.rb

#interpret_AccessExpression(ast, context) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

# File 'lib/puppet/pops/types/type_parser.rb', line 302

def interpret_AccessExpression(ast, context)
  parameters = ast.keys.collect { |param| interpret_any(param, context) }

  qref = ast.left_expr
  raise_invalid_type_specification_error(ast) unless qref.is_a?(Model::QualifiedReference)

  type_name = qref.value
  case type_name
  when 'array'
    case parameters.size
    when 1
      type = assert_type(ast, parameters[0])
    when 2
      if parameters[0].is_a?(PAnyType)
        type = parameters[0]
        size_type =
          if parameters[1].is_a?(PIntegerType)
            size_type = parameters[1]
          else
            assert_range_parameter(ast, parameters[1])
            TypeFactory.range(parameters[1], :default)
          end
      else
        type = :default
        assert_range_parameter(ast, parameters[0])
        assert_range_parameter(ast, parameters[1])
        size_type = TypeFactory.range(parameters[0], parameters[1])
      end
    when 3
      type = assert_type(ast, parameters[0])
      assert_range_parameter(ast, parameters[1])
      assert_range_parameter(ast, parameters[2])
      size_type = TypeFactory.range(parameters[1], parameters[2])
    else
      raise_invalid_parameters_error('Array', '1 to 3', parameters.size)
    end
    TypeFactory.array_of(type, size_type)

  when 'hash'
    case parameters.size
    when 2
      if parameters[0].is_a?(PAnyType) && parameters[1].is_a?(PAnyType)
        TypeFactory.hash_of(parameters[1], parameters[0])
      else
        assert_range_parameter(ast, parameters[0])
        assert_range_parameter(ast, parameters[1])
        TypeFactory.hash_of(:default, :default, TypeFactory.range(parameters[0], parameters[1]))
      end
    when 3
      size_type =
        if parameters[2].is_a?(PIntegerType)
          parameters[2]
        else
          assert_range_parameter(ast, parameters[2])
          TypeFactory.range(parameters[2], :default)
        end
      assert_type(ast, parameters[0])
      assert_type(ast, parameters[1])
      TypeFactory.hash_of(parameters[1], parameters[0], size_type)
    when 4
      assert_range_parameter(ast, parameters[2])
      assert_range_parameter(ast, parameters[3])
      assert_type(ast, parameters[0])
      assert_type(ast, parameters[1])
      TypeFactory.hash_of(parameters[1], parameters[0], TypeFactory.range(parameters[2], parameters[3]))
    else
      raise_invalid_parameters_error('Hash', '2 to 4', parameters.size)
    end

  when 'collection'
    size_type = case parameters.size
      when 1
        if parameters[0].is_a?(PIntegerType)
          parameters[0]
        else
          assert_range_parameter(ast, parameters[0])
          TypeFactory.range(parameters[0], :default)
        end
      when 2
        assert_range_parameter(ast, parameters[0])
        assert_range_parameter(ast, parameters[1])
        TypeFactory.range(parameters[0], parameters[1])
      else
        raise_invalid_parameters_error('Collection', '1 to 2', parameters.size)
      end
    TypeFactory.collection(size_type)

  when 'class'
    if parameters.size != 1
      raise_invalid_parameters_error('Class', 1, parameters.size)
    end
    TypeFactory.host_class(parameters[0])

  when 'resource'
    type = parameters[0]
    if type.is_a?(PTypeReferenceType)
      type_str = type.type_string
      param_start = type_str.index('[')
      if param_start.nil?
        type = type_str
      else
        tps = interpret_any(@parser.parse_string(type_str[param_start..-1]).model, context)
        raise_invalid_parameters_error(type.to_s, '1', tps.size) unless tps.size == 1
        type = type_str[0..param_start-1]
        parameters = [type] + tps
      end
    end
    create_resource(type, parameters)

  when 'regexp'
    # 1 parameter being a string, or regular expression
    raise_invalid_parameters_error('Regexp', '1', parameters.size) unless parameters.size == 1
    TypeFactory.regexp(parameters[0])

  when 'enum'
    # 1..m parameters being string
    last = parameters.last
    case_insensitive = false
    if last == true || last == false
      parameters = parameters[0...-1]
      case_insensitive = last
    end
    raise_invalid_parameters_error('Enum', '1 or more', parameters.size) unless parameters.size >= 1
    parameters.each { |p| raise Puppet::ParseError, _('Enum parameters must be identifiers or strings') unless p.is_a?(String) }
    PEnumType.new(parameters, case_insensitive)

  when 'pattern'
    # 1..m parameters being strings or regular expressions
    raise_invalid_parameters_error('Pattern', '1 or more', parameters.size) unless parameters.size >= 1
    TypeFactory.pattern(*parameters)

  when 'uri'
    # 1 parameter which is a string or a URI
    raise_invalid_parameters_error('URI', '1', parameters.size) unless parameters.size == 1
    TypeFactory.uri(parameters[0])

  when 'variant'
    # 1..m parameters being strings or regular expressions
    raise_invalid_parameters_error('Variant', '1 or more', parameters.size) unless parameters.size >= 1
    parameters.each { |p| assert_type(ast, p) }
    TypeFactory.variant(*parameters)

  when 'tuple'
    # 1..m parameters being types (last two optionally integer or literal default
    raise_invalid_parameters_error('Tuple', '1 or more', parameters.size) unless parameters.size >= 1
    length = parameters.size
    size_type = nil
    if TypeFactory.is_range_parameter?(parameters[-2])
      # min, max specification
      min = parameters[-2]
      min = (min == :default || min == 'default') ? 0 : min
      assert_range_parameter(ast, parameters[-1])
      max = parameters[-1]
      max = max == :default ? nil : max
      parameters = parameters[0, length-2]
      size_type = TypeFactory.range(min, max)
    elsif TypeFactory.is_range_parameter?(parameters[-1])
      min = parameters[-1]
      min = (min == :default || min == 'default') ? 0 : min
      max = nil
      parameters = parameters[0, length-1]
      size_type = TypeFactory.range(min, max)
    end
    TypeFactory.tuple(parameters, size_type)

  when 'callable'
    # 1..m parameters being types (last three optionally integer or literal default, and a callable)
    if parameters.size > 1 && parameters[0].is_a?(Array)
      raise_invalid_parameters_error('callable', '2 when first parameter is an array', parameters.size) unless parameters.size == 2
    end
    TypeFactory.callable(*parameters)

  when 'struct'
    # 1..m parameters being types (last two optionally integer or literal default
    raise_invalid_parameters_error('Struct', '1', parameters.size) unless parameters.size == 1
    h = parameters[0]
    raise_invalid_type_specification_error(ast) unless h.is_a?(Hash)
    TypeFactory.struct(h)

  when 'boolean'
    raise_invalid_parameters_error('Boolean', '1', parameters.size) unless parameters.size == 1
    p = parameters[0]
    raise Puppet::ParseError, 'Boolean parameter must be true or false' unless p == true || p == false
    TypeFactory.boolean(p)

  when 'integer'
    if parameters.size == 1
      case parameters[0]
      when Integer
        TypeFactory.range(parameters[0], :default)
      when :default
        TypeFactory.integer # unbound
      end
    elsif parameters.size != 2
      raise_invalid_parameters_error('Integer', '1 or 2', parameters.size)
    else
      TypeFactory.range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
    end

  when 'object'
    raise_invalid_parameters_error('Object', 1, parameters.size) unless parameters.size == 1
    TypeFactory.object(parameters[0])

  when 'typeset'
    raise_invalid_parameters_error('Object', 1, parameters.size) unless parameters.size == 1
    TypeFactory.type_set(parameters[0])

  when 'init'
    assert_type(ast, parameters[0])
    TypeFactory.init(*parameters)

  when 'iterable'
    if parameters.size != 1
      raise_invalid_parameters_error('Iterable', 1, parameters.size)
    end
    assert_type(ast, parameters[0])
    TypeFactory.iterable(parameters[0])

  when 'iterator'
    if parameters.size != 1
      raise_invalid_parameters_error('Iterator', 1, parameters.size)
    end
    assert_type(ast, parameters[0])
    TypeFactory.iterator(parameters[0])

  when 'float'
    if parameters.size == 1
      case parameters[0]
      when Integer, Float
        TypeFactory.float_range(parameters[0], :default)
      when :default
        TypeFactory.float # unbound
      end
    elsif parameters.size != 2
      raise_invalid_parameters_error('Float', '1 or 2', parameters.size)
    else
      TypeFactory.float_range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
    end

  when 'string'
    size_type =
    case parameters.size
    when 1
      if parameters[0].is_a?(PIntegerType)
        parameters[0]
      else
        assert_range_parameter(ast, parameters[0])
        TypeFactory.range(parameters[0], :default)
      end
    when 2
      assert_range_parameter(ast, parameters[0])
      assert_range_parameter(ast, parameters[1])
      TypeFactory.range(parameters[0], parameters[1])
    else
      raise_invalid_parameters_error('String', '1 to 2', parameters.size)
    end
    TypeFactory.string(size_type)

  when 'sensitive'
    if parameters.size == 0
      TypeFactory.sensitive
    elsif parameters.size == 1
      param = parameters[0]
      assert_type(ast, param)
      TypeFactory.sensitive(param)
    else
      raise_invalid_parameters_error('Sensitive', '0 to 1', parameters.size)
    end

  when 'optional'
    if parameters.size != 1
      raise_invalid_parameters_error('Optional', 1, parameters.size)
    end
    param = parameters[0]
    assert_type(ast, param) unless param.is_a?(String)
    TypeFactory.optional(param)

  when 'any', 'data', 'catalogentry', 'scalar', 'undef', 'numeric', 'default', 'semverrange'
    raise_unparameterized_type_error(qref)

  when 'notundef'
    case parameters.size
    when 0
      TypeFactory.not_undef
    when 1
      param = parameters[0]
      assert_type(ast, param) unless param.is_a?(String)
      TypeFactory.not_undef(param)
    else
      raise_invalid_parameters_error("NotUndef", "0 to 1", parameters.size)
    end

  when 'type'
    if parameters.size != 1
      raise_invalid_parameters_error('Type', 1, parameters.size)
    end
    assert_type(ast, parameters[0])
    TypeFactory.type_type(parameters[0])

  when 'runtime'
    raise_invalid_parameters_error('Runtime', '2', parameters.size) unless parameters.size == 2
    TypeFactory.runtime(*parameters)

  when 'timespan'
    raise_invalid_parameters_error('Timespan', '0 to 2', parameters.size) unless parameters.size <= 2
    TypeFactory.timespan(*parameters)

  when 'timestamp'
    raise_invalid_parameters_error('Timestamp', '0 to 2', parameters.size) unless parameters.size <= 2
    TypeFactory.timestamp(*parameters)

  when 'semver'
    raise_invalid_parameters_error('SemVer', '1 or more', parameters.size) unless parameters.size >= 1
    TypeFactory.sem_ver(*parameters)

  else
    loader = loader_from_context(qref, context)
    type = nil
    unless loader.nil?
      type = loader.load(:type, type_name)
      type = type.resolve(loader) unless type.nil?
    end

    if type.nil?
      TypeFactory.type_reference(original_text_of(ast))
    elsif type.is_a?(PResourceType)
      raise_invalid_parameters_error(qref.cased_value, 1, parameters.size) unless parameters.size == 1
      TypeFactory.resource(type.type_name, parameters[0])
    elsif type.is_a?(PObjectType)
      PObjectTypeExtension.create(type, parameters)
    else
      # Must be a type alias. They can't use parameters (yet)
      raise_unparameterized_type_error(qref)
    end
  end
end