puppet-retrospec 1.5.0 → 1.6.0

data/vendor/pup410/lib/puppet/pops/parser/slurp_support.rb

@@ -0,0 +1,120 @@
+module Puppet::Pops
+module Parser
+# This module is an integral part of the Lexer.
+# It defines the string slurping behavior - finding the string and non string parts in interpolated
+# strings, translating escape sequences in strings to their single character equivalence.
+#
+# PERFORMANCE NOTE: The various kinds of slurping could be made even more generic, but requires
+# additional parameter passing and evaluation of conditional logic.
+# TODO: More detailed performance analysis of excessive character escaping and interpolation.
+#
+module SlurpSupport
+  include LexerSupport
+
+  SLURP_SQ_PATTERN  = /(?:[^\\]|^)(?:[\\]{2})*[']/
+  SLURP_DQ_PATTERN  = /(?:[^\\]|^)(?:[\\]{2})*(["]|[$]\{?)/
+  SLURP_UQ_PATTERN  = /(?:[^\\]|^)(?:[\\]{2})*([$]\{?|\z)/
+  # unquoted, no escapes
+  SLURP_UQNE_PATTERN  = /(\$\{?|\z)/m
+  SLURP_ALL_PATTERN = /.*(\z)/m
+  SQ_ESCAPES = %w{ \\ ' }
+  DQ_ESCAPES = %w{ \\  $ ' " r n t s u}+["\r\n", "\n"]
+  UQ_ESCAPES = %w{ \\  $ r n t s u}+["\r\n", "\n"]
+
+  def slurp_sqstring
+    # skip the leading '
+    @scanner.pos += 1
+    str = slurp(@scanner, SLURP_SQ_PATTERN, SQ_ESCAPES, :ignore_invalid_escapes)
+    lex_error(Issues::UNCLOSED_QUOTE, :after => "\"'\"", :followed_by => followed_by) unless str
+    str[0..-2] # strip closing "'" from result
+  end
+
+  def slurp_dqstring
+    scn = @scanner
+    last = scn.matched
+    str = slurp(scn, SLURP_DQ_PATTERN, DQ_ESCAPES, false)
+    unless str
+      lex_error(Issues::UNCLOSED_QUOTE, :after => format_quote(last), :followed_by => followed_by)
+    end
+
+    # Terminator may be a single char '"', '$', or two characters '${' group match 1 (scn[1]) from the last slurp holds this
+    terminator = scn[1]
+    [str[0..(-1 - terminator.length)], terminator]
+  end
+
+   # Copy from old lexer - can do much better
+   def slurp_uqstring
+     scn = @scanner
+     last = scn.matched
+     ignore = true
+
+     str = slurp(scn, @lexing_context[:uq_slurp_pattern], @lexing_context[:escapes], :ignore_invalid_escapes)
+
+     # Terminator may be a single char '$', two characters '${', or empty string '' at the end of intput.
+     # Group match 1 holds this.
+     # The exceptional case is found by looking at the subgroup 1 of the most recent match made by the scanner (i.e. @scanner[1]).
+     # This is the last match made by the slurp method (having called scan_until on the scanner).
+     # If there is a terminating character is must be stripped and returned separately.
+     #
+     terminator = scn[1]
+     [str[0..(-1 - terminator.length)], terminator]
+   end
+
+  # Slurps a string from the given scanner until the given pattern and then replaces any escaped
+  # characters given by escapes into their control-character equivalent or in case of line breaks, replaces the
+  # pattern \r?\n with an empty string.
+  # The returned string contains the terminating character. Returns nil if the scanner can not scan until the given
+  # pattern.
+  #
+  def slurp(scanner, pattern, escapes, ignore_invalid_escapes)
+    str = scanner.scan_until(pattern) || return
+
+    return str unless str.include?('\\')
+
+    return str.gsub!(/\\(\\|')/m, '\1') || str if escapes.equal?(SQ_ESCAPES)
+
+    # Process unicode escapes first as they require getting 4 hex digits
+    # If later a \u is found it is warned not to be a unicode escape
+    if escapes.include?('u')
+      # gsub must be repeated to cater for adjacent escapes
+      while(str.gsub!(/((?:[^\\]|^)(?:[\\]{2})*)\\u(?:([\da-fA-F]{4})|\{([\da-fA-F]{1,6})\})/m) { $1 + [($2 || $3).hex].pack("U") })
+        # empty block. Everything happens in the gsub block
+      end
+    end
+
+    begin
+    str.gsub!(/\\([^\r\n]|(?:\r?\n))/m) {
+      ch = $1
+      if escapes.include? ch
+        case ch
+        when 'r'   ; "\r"
+        when 'n'   ; "\n"
+        when 't'   ; "\t"
+        when 's'   ; ' '
+        when 'u'
+          lex_warning(Issues::ILLEGAL_UNICODE_ESCAPE)
+          "\\u"
+        when "\n"  ; ''
+        when "\r\n"; ''
+        else      ch
+        end
+      else
+        lex_warning(Issues::UNRECOGNIZED_ESCAPE, :ch => ch) unless ignore_invalid_escapes
+        "\\#{ch}"
+      end
+    }
+    rescue ArgumentError => e
+      # A invalid byte sequence may be the result of faulty input as well, but that could not possibly
+      # have reached this far... Unfortunately there is no more specific error and a match on message is
+      # required to differentiate from other internal problems.
+      if e.message =~ /invalid byte sequence/
+        lex_error(Issues::ILLEGAL_UNICODE_ESCAPE)
+      else
+        raise e
+      end
+    end
+    str
+  end
+end
+end
+end

data/vendor/pup410/lib/puppet/pops/patterns.rb

@@ -0,0 +1,60 @@
+# The Patterns module contains common regular expression patters for the Puppet DSL language
+module Puppet::Pops::Patterns
+
+  # NUMERIC matches hex, octal, decimal, and floating point and captures several parts
+  # 0 = entire matched number, leading and trailing whitespace and sign included
+  # 1 = sign, +, - or nothing
+  # 2 = entire numeric part
+  # 3 = hexadecimal number
+  # 4 = non hex integer portion, possibly with leading 0 (octal)
+  # 5 = floating point part, starts with ".", decimals and optional exponent
+  #
+  # Thus, a hex number has group 3 value, an octal value has group 4 (if it starts with 0), and no group 3
+  # and a floating point value has group 4 and group 5.
+  #
+  NUMERIC = %r{\A[[:blank:]]*([-+]?)[[:blank:]]*((0[xX][0-9A-Fa-f]+)|(0?\d+)((?:\.\d+)?(?:[eE]-?\d+)?))[[:blank:]]*\z}
+
+  # Special expression that tests if there is whitespace between sign and number. The expression is used
+  # to strip such whitespace when normal Float or Integer conversion fails.
+  WS_BETWEEN_SIGN_AND_NUMBER = %r{\A([+-])[[:blank:]]+(.*)\z}
+
+  # ILLEGAL_P3_1_HOSTNAME matches if a hostname contains illegal characters.
+  # This check does not prevent pathological names like 'a....b', '.....', "---". etc.
+  ILLEGAL_HOSTNAME_CHARS = %r{[^-\w.]}
+
+  # NAME matches a name the same way as the lexer.
+  NAME = %r{\A((::)?[a-z]\w*)(::[a-z]\w*)*\z}
+
+  # CLASSREF_EXT matches a class reference the same way as the lexer - i.e. the external source form
+  # where each part must start with a capital letter A-Z.
+  #
+  CLASSREF_EXT = %r{\A((::){0,1}[A-Z][\w]*)+\z}
+
+  # Same as CLASSREF_EXT but cannot start with '::'
+  #
+  CLASSREF_EXT_DECL = %r{\A[A-Z][\w]*(?:::[A-Z][\w]*)*\z}
+
+  # CLASSREF matches a class reference the way it is represented internally in the
+  # model (i.e. in lower case).
+  #
+  CLASSREF = %r{\A((::){0,1}[a-z][\w]*)+\z}
+
+  # Same as CLASSREF but cannot start with '::'
+  #
+  CLASSREF_DECL = %r{\A[a-z][\w]*(?:::[a-z][\w]*)*\z}
+
+  # DOLLAR_VAR matches a variable name including the initial $ character
+  DOLLAR_VAR     = %r{\$(::)?(\w+::)*\w+}
+
+  # VAR_NAME matches the name part of a variable (The $ character is not included)
+  # Note, that only the final segment may start with an underscore.
+  # Note, regexp sensitive to backtracking
+  VAR_NAME = %r{\A(?:::)?(?:[a-z]\w*::)*[a-z_]\w*\z}
+
+  # PARAM_NAME matches the name part of a parameter (The $ character is not included)
+  PARAM_NAME = %r{\A[a-z_]\w*\z}
+
+  # A Numeric var name must be the decimal number 0, or a decimal number not starting with 0
+  NUMERIC_VAR_NAME = %r{\A(?:0|(?:[1-9][0-9]*))\z}
+
+end

data/vendor/pup410/lib/puppet/pops/pcore.rb

@@ -0,0 +1,96 @@
+require 'uri'
+
+module Puppet::Pops
+module Pcore
+  TYPE_URI_RX = Types::TypeFactory.regexp(URI.regexp)
+  TYPE_URI = Types::TypeFactory.pattern(TYPE_URI_RX)
+  TYPE_URI_ALIAS = Types::PTypeAliasType.new('Pcore::URI', nil, TYPE_URI)
+  TYPE_SIMPLE_TYPE_NAME = Types::TypeFactory.pattern(/\A[A-Z]\w*\z/)
+  TYPE_QUALIFIED_REFERENCE = Types::TypeFactory.pattern(/\A[A-Z][\w]*(?:::[A-Z][\w]*)*\z/)
+
+  KEY_PCORE_URI = 'pcore_uri'.freeze
+  KEY_PCORE_VERSION = 'pcore_version'.freeze
+
+  PCORE_URI = 'http://puppet.com/2016.1/pcore'
+  PCORE_VERSION = SemanticPuppet::Version.new(1,0,0)
+  PARSABLE_PCORE_VERSIONS = SemanticPuppet::VersionRange.parse('1.x')
+
+  RUNTIME_NAME_AUTHORITY = 'http://puppet.com/2016.1/runtime'
+
+  def self.init(loader, ir, for_agent)
+    add_alias('Pcore::URI_RX', TYPE_URI_RX, loader)
+    add_type(TYPE_URI_ALIAS, loader)
+    add_alias('Pcore::SimpleTypeName', TYPE_SIMPLE_TYPE_NAME, loader)
+    add_alias('Pcore::TypeName', TYPE_QUALIFIED_REFERENCE, loader)
+    add_alias('Pcore::QRef', TYPE_QUALIFIED_REFERENCE, loader)
+    begin
+    Types::TypedModelObject.register_ptypes(loader, ir)
+    rescue Exception => e
+      puts e.message
+    end
+
+    ir.register_implementation_namespace('Pcore', 'Puppet::Pops::Pcore', loader)
+    unless for_agent
+      ir.register_implementation_namespace('Puppet::AST', 'Puppet::Pops::Model', loader)
+      ast_type_set = Serialization::RGen::TypeGenerator.new.generate_type_set('Puppet::AST', Puppet::Pops::Model, loader)
+
+      # Extend the Puppet::AST type set with the Locator (it's not an RGen class, but nevertheless, used in the model)
+      ast_ts_i12n = ast_type_set.i12n_hash
+      ast_ts_i12n['types'] = ast_ts_i12n['types'].merge('Locator' => Parser::Locator::Locator19.register_ptype(loader, ir))
+      add_type(Types::PTypeSetType.new(ast_ts_i12n), loader)
+
+      Resource.register_ptypes(loader, ir)
+      Lookup::Context.register_ptype(loader, ir);
+      Lookup::DataProvider.register_types(loader)
+    end
+  end
+
+  # Create and register a new `Object` type in the Puppet Type System and map it to an implementation class
+  #
+  # @param loader [Loader::Loader] The loader where the new type will be registered
+  # @param ir [ImplementationRegistry] The implementation registry that maps this class to the new type
+  # @param impl_class [Class] The class that is the implementation of the type
+  # @param type_name [String] The fully qualified name of the new type
+  # @param parent_name [String,nil] The fully qualified name of the parent type
+  # @param attributes_hash [Hash{String => Object}] A hash of attribute definitions for the new type
+  # @param functions_hash [Hash{String => Object}] A hash of function definitions for the new type
+  # @param equality [Array<String>] An array with names of attributes that participate in equality comparison
+  # @return [PObjectType] the created type. Not yet resolved
+  #
+  # @api private
+  def self.create_object_type(loader, ir, impl_class, type_name, parent_name, attributes_hash = EMPTY_HASH, functions_hash = EMPTY_HASH, equality = nil)
+    i12n_hash = {}
+    i12n_hash[Types::KEY_PARENT] = Types::PTypeReferenceType.new(parent_name) unless parent_name.nil?
+    i12n_hash[Types::KEY_ATTRIBUTES] = attributes_hash unless attributes_hash.empty?
+    i12n_hash[Types::KEY_FUNCTIONS] = functions_hash unless functions_hash.empty?
+    i12n_hash[Types::KEY_EQUALITY] = equality unless equality.nil?
+    ir.register_implementation(type_name, impl_class, loader)
+    add_type(Types::PObjectType.new(type_name, i12n_hash), loader)
+  end
+
+  def self.add_object_type(name, body, loader)
+    add_type(Types::PObjectType.new(name, Parser::EvaluatingParser.new.parse_string(body).current.body), loader)
+  end
+
+  def self.add_alias(name, type, loader, name_authority = RUNTIME_NAME_AUTHORITY)
+    add_type(Types::PTypeAliasType.new(name, nil, type), loader, name_authority)
+  end
+
+  def self.add_type(type, loader, name_authority = RUNTIME_NAME_AUTHORITY)
+    loader.set_entry(Loader::TypedName.new(:type, type.name, name_authority), type)
+    type
+  end
+
+  def self.register_implementations(impls, name_authority = RUNTIME_NAME_AUTHORITY)
+    Loaders.loaders.register_implementations(impls, name_authority)
+  end
+
+  def self.register_aliases(aliases, name_authority = RUNTIME_NAME_AUTHORITY, loader = Loaders.loaders.private_environment_loader)
+    aliases.each do |name, type_string|
+      add_type(Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(type_string), nil), loader, name_authority)
+    end
+    parser = Types::TypeParser.singleton
+    aliases.each_key.map { |name| loader.load(:type, name).resolve(parser, loader) }
+  end
+end
+end

data/vendor/pup410/lib/puppet/pops/puppet_stack.rb

@@ -0,0 +1,43 @@
+module Puppet::Pops
+# Module for making a call such that there is an identifiable entry on
+# the ruby call stack enabling getting a puppet call stack
+# To use this make a call with:
+# ```
+# Puppet::Pops::PuppetStack.stack(file, line, receiver, message, args)
+# ```
+# To get the stack call:
+# ```
+# Puppet::Pops::PuppetStack.stacktrace
+#
+# When getting a backtrace in Ruby, the puppet stack frames are
+# identified as coming from "in 'stack'" and having a ".pp" file
+# name.
+# To support testing, a given file that is an empty string, or nil
+# as well as a nil line number are supported. Such stack frames
+# will be represented with the text `unknown` and `0´ respectively.
+#
+module PuppetStack
+  # Sends a message to an obj such that it appears to come from
+  # file, line when calling stacktrace.
+  #
+  def self.stack(file, line, obj, message, args, &block)
+    file = '' if file.nil?
+    line = 0 if line.nil?
+
+    if block_given?
+      Kernel.eval("obj.send(message, *args, &block)", Kernel.binding(), file, line)
+    else
+      Kernel.eval("obj.send(message, *args)", Kernel.binding(), file, line)
+    end
+  end
+
+  def self.stacktrace
+    caller().reduce([]) do |memo, loc|
+      if loc =~ /^(.*\.pp)?:([0-9]+):in (`stack'|`block in call_function')/
+        memo << [$1.nil? ? 'unknown' : $1, $2.to_i]
+      end
+      memo
+    end
+  end
+end
+end

data/vendor/pup410/lib/puppet/pops/resource/param.rb

@@ -0,0 +1,55 @@
+# An implementation of the interface Puppet::Resource
+# that adapts the 3.x compiler and catalog expectations on
+# a resource instance. This instance is backed by a
+# pcore representation of the resource type an instance of this
+# ruby class.
+#
+# This class must inherit from Puppet::Resource because of the
+# class expectations in existing logic.
+#
+# This implementation does not support
+# * setting 'strict' - strictness (must refer to an existing type) is always true
+# * does not support the indirector
+#
+#
+module Puppet::Pops
+module Resource
+class Param
+  # This make this class instantiateable from Puppet
+  include Puppet::Pops::Types::PuppetObject
+
+  def self.register_ptype(loader, ir)
+    @ptype = Pcore::create_object_type(loader, ir, self, 'Puppet::Resource::Param', nil,
+      {
+        Types::KEY_TYPE => Types::PType::DEFAULT,
+        Types::KEY_NAME => Types::PStringType::NON_EMPTY,
+        'name_var' => {
+          Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
+          Types::KEY_VALUE => false
+        }
+      },
+      EMPTY_HASH,
+      [Types::KEY_NAME]
+    )
+  end
+
+  attr_reader :name
+  attr_reader :type
+  attr_reader :name_var
+
+  def initialize(type, name, name_var = false)
+    @type = type
+    @name = name
+    @name_var = name_var
+  end
+
+  def to_s
+    name
+  end
+
+  def self._ptype
+    @ptype
+  end
+end
+end
+end

data/vendor/pup410/lib/puppet/pops/resource/resource_type_impl.rb

@@ -0,0 +1,314 @@
+require_relative 'param'
+
+module Puppet::Pops
+module Resource
+
+def self.register_ptypes(loader, ir)
+  types = [Param, ResourceTypeImpl].map do |c|
+    c.register_ptype(loader, ir)
+  end
+  types.each {|t| t.resolve(Types::TypeParser.singleton, loader) }
+end
+
+class ResourceTypeImpl
+  # Make instances of this class directly createable from the Puppet Language
+  # as object.
+  #
+  include Puppet::Pops::Types::PuppetObject
+
+  # Instances of ResourceTypeImpl can be used as the type of a Puppet::Parser::Resource/Puppet::Resource when compiling
+  #
+  include Puppet::CompilableResourceType
+
+  # Returns the Puppet Type for this instance.
+  def self._ptype
+    @ptype
+  end
+
+  def self.register_ptype(loader, ir)
+    param_ref = Types::PTypeReferenceType.new('Puppet::Resource::Param')
+    @ptype = Pcore::create_object_type(loader, ir, self, 'Puppet::Resource::ResourceType3', nil,
+      {
+        Types::KEY_NAME => Types::PStringType::NON_EMPTY,
+        'properties' => {
+          Types::KEY_TYPE => Types::PArrayType.new(param_ref),
+          Types::KEY_VALUE => EMPTY_ARRAY
+        },
+        'parameters' => {
+          Types::KEY_TYPE => Types::PArrayType.new(param_ref),
+          Types::KEY_VALUE => EMPTY_ARRAY
+        },
+        'title_patterns_hash' => {
+          Types::KEY_TYPE => Types::POptionalType.new(
+            Types::PHashType.new(Types::PRegexpType::DEFAULT, Types::PArrayType.new(Types::PStringType::NON_EMPTY))),
+          Types::KEY_VALUE => nil
+        },
+        'isomorphic' => {
+          Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
+          Types::KEY_VALUE => true
+        },
+        'capability' => {
+          Types::KEY_TYPE => Types::PBooleanType::DEFAULT,
+          Types::KEY_VALUE => false
+        },
+      },
+      EMPTY_HASH,
+      [Types::KEY_NAME]
+    )
+  end
+
+  def eql?(other)
+    other.is_a?(Puppet::CompilableResourceType) && @name == other.name
+  end
+  alias == eql?
+
+  # Compares this type against the given _other_ (type) and returns -1, 0, or +1 depending on the order.
+  # @param other [Object] the object to compare against (produces nil, if not kind of Type}
+  # @return [-1, 0, +1, nil] produces -1 if this type is before the given _other_ type, 0 if equals, and 1 if after.
+  #   Returns nil, if the given _other_ is not a kind of Type.
+  # @see Comparable
+  #
+  def <=>(other)
+    # Order is only maintained against other types, not arbitrary objects.
+    # The natural order is based on the reference name used when comparing
+    return nil unless other.is_a?(Puppet::CompilableResourceType)
+    # against other type instances.
+    self.ref <=> other.ref
+  end
+
+  METAPARAMS = [
+    :noop,
+    :schedule,
+    :audit,
+    :loglevel,
+    :alias,
+    :tag,
+    :require,
+    :subscribe,
+    :before,
+    :notify,
+    :stage,
+    :export,
+    :consume
+    ].freeze
+
+  # Speed up lookup
+  METAPARAMSET = Set.new(METAPARAMS).freeze
+
+  attr_reader :name
+  attr_reader :properties
+  attr_reader :parameters
+  attr_reader :title_patterns_hash
+  attr_reader :title_patterns
+
+  def initialize(name, properties = EMPTY_ARRAY, parameters = EMPTY_ARRAY, title_patterns_hash = nil, isomorphic = true, capability = false)
+    @name = name
+    @properties = properties
+    @parameters = parameters
+    @title_patterns_hash = title_patterns_hash
+    @isomorphic = isomorphic
+    @capability = capability
+
+    # Compute attributes hash
+    # Compute key_names (possibly compound key if there are multiple name vars).
+    @attributes = {}
+    @key_attributes = []
+
+    # Name to kind of attribute
+    @attr_types = {}
+
+    # Add all meta params
+    METAPARAMS.each {|p| @attr_types[p] = :meta }
+
+    @property_set = Set.new(properties.map do |p|
+      symname = p.name.to_sym
+      @attributes[symname] = p
+      @key_attributes << symname if p.name_var
+      @attr_types[symname] = :property
+      symname
+    end).freeze
+
+    @param_set = Set.new(parameters.map do |p|
+      symname = p.name.to_sym
+      @attributes[symname] = p
+      @key_attributes << symname if p.name_var
+      @attr_types[symname] = :param
+      symname
+    end).freeze
+
+    # API for title patterns is [ [regexp, [ [ [sym, <lambda>], [sym, <lambda>] ] ] ] ]
+    # Where lambdas are optional. This resource type impl does not support lambdas
+    # Note that the pcore file has a simpler hashmap that is post processed here
+    # since the structure must have Symbol instances for names which the .pp representation
+    # does not deliver.
+    #
+    @title_patterns =
+      case @key_attributes.length
+      when 0
+        # TechDebt: The case of specifying title patterns when having no name vars is unspecified behavior in puppet
+        # Here it is silently ignored.
+        nil
+      when 1
+        if @title_pattners_hash.nil?
+          [ [ /(.*)/m, [ [@key_attributes.first] ] ] ]
+        else
+          # TechDebt: The case of having one namevar and an empty title patterns is unspecified behavior in puppet.
+          # Here, it may lead to an empty map which may or may not trigger the wanted/expected behavior.
+          #
+          @title_patterns_hash.map { |k,v| [ k, v.map { |n| [ n.to_sym ] } ] }
+        end
+      else
+        if @title_patterns_hash.nil? || @title_patterns_hash.empty?
+          # TechDebt: While title patterns must be specified when more than one is used, they do not have
+          # to match/set them all since some namevars can be omitted (to support the use case in
+          # the 'package' type where 'provider' attribute is handled as part of the key without being
+          # set from the title.
+          #
+          raise Puppet::DevError,"you must specify title patterns when there are two or more key attributes"
+        end
+        @title_patterns_hash.nil? ? [] : @title_patterns_hash.map { |k,v| [ k, v.map { |n| [ n.to_sym] } ] }
+      end
+  end
+
+  # Override CompilableResource inclusion
+  def is_3x_ruby_plugin?
+    false
+  end
+
+  def is_capability?
+    @capability
+  end
+
+  # Answers if the parameter name is a parameter/attribute of this type
+  # This is part of the Puppet::Type API
+  # Check if used when compiling (it is triggered in an apply)
+  #
+  def valid_parameter?(name)
+    @attributes.include?(name) || METAPARAMSET.include?(name)
+  end
+
+  # The type implementation of finish does a lot of things
+  # * iterates over all parameters and calls post_compile on them if the parameter impl responds to post_compile
+  # * validates the relationship parameters
+  #
+  # This implementation does nothing - it is assumed that the catalog is already validated
+  # via the relationship validator (done late in the game).
+  def finish()
+    # Do nothing.
+  end
+
+  # This is called on a resource type
+  # it performs tagging if it is a Class or Node.
+  # It also ensure the parent type is in the catalog, but that is weird since
+  # resource types cannot really inherit
+  def instantiate_resource(scope, resource)
+    # Do nothing because nothing is needed when compiling.
+
+    # This is what the Puppet::Type implementation does
+    # None of this should be needed
+
+      #    # Make sure our parent class has been evaluated, if we have one.
+      #    if parent && !scope.catalog.resource(resource.type, parent)
+      #      parent_type(scope).ensure_in_catalog(scope)
+      #    end
+
+    # This will never happen
+
+      #    if ['Class', 'Node'].include? resource.type
+      #      scope.catalog.tag(*resource.tags)
+      #    end
+  end
+
+  # Being isomorphic in puppet means that the resource is managing a state
+  # (as opposed to a resource like Exec that is a function, possibly with side effect.
+  # In a Ruby implementation of a resource type, @isomorphic = false is used to turn
+  # off isomorphism, it is true by default.
+  # This is part of the Puppet::Type API.
+  #
+  def isomorphic?
+    @isomorphic
+  end
+
+  # Produces the names of the attributes that make out the unique id of a resource
+  #
+  def key_attributes
+    @key_attributes
+  end
+
+  # Gives a type a chance to issue deprecations for parameters.
+  # @param title [String] the title of the resource of this type
+  # @param attributes [Array<Param>] the set parameters in the resource instance
+  def deprecate_params(title, attributes)
+    # TODO: Current API somewhat unclear, if done at type level, or per
+    #       Param.
+  end
+
+  #######################
+  # UNSUPPORTED STUFF
+  #######################
+
+  # Applications are not supported
+  def application?
+    false
+  end
+
+  ############################
+  # DON'T KNOW YET
+  ############################
+
+
+  ##################################################
+  # NEVER CALLED COMPILE SIDE FOR A COMPILATION
+  ##################################################
+
+  # Answers :property, :param or :meta depending on the type of the attribute
+  # According to original version, this is called millions of times
+  # and a cache is required.
+  # @param name [Symbol]
+  def attrtype(name)
+    raise NotImplementedError, "attrtype() - returns the kind (:meta, :param, or :property) of the parameter"
+    # @attr_types[name]
+  end
+
+  # Returns the implementation of a param/property/attribute - i.e. a Param class
+  def attrclass(name)
+    raise NotImplementedError, "attrclass() - returns the (param) class of the parameter"
+  end
+
+  # PROBABLY NOT USED WHEN COMPILING
+  # Returns the names of all attributes in a defined order:
+  # * all key attributes (the composite id)
+  # * :provider if it is specified
+  # * all properties
+  # * all parameters
+  # * meta parameters
+  #
+  def allattrs
+    raise NotImplementedError, "allattrs() - return all attribute names in order - probably not used master side"
+    # key_attributes | (parameters & [:provider]) | properties.collect { |property| property.name } | parameters | metaparams
+  end
+
+  # Sets "applies to host"
+  def apply_to
+    raise NotImplementedError, "apply_to() - probably used when selecting a provider (device/host support)"
+  end
+
+  def apply_to_host
+    raise NotImplementedError, "apply_to_host() - probably used when selecting a provider (device/host support)"
+  end
+
+  def apply_to_device
+    raise NotImplementedError, "apply_to_device() - probably used when selecting a provider (device/host support)"
+  end
+
+  def apply_to_all
+    raise NotImplementedError, "apply_to_all() - probably used when selecting a provider (device/host support)"
+  end
+
+  def can_apply_to_target(target)
+    raise NotImplementedError, "can_apply_to_target() - probably used when selecting a provider (device/host support)"
+  end
+
+end
+end
+end