puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/lib/puppet/parser/parser_support.rb

@@ -1,195 +0,0 @@
-# I pulled this into a separate file, because I got
-# tired of rebuilding the parser.rb file all the time.
-require 'forwardable'
-
-class Puppet::Parser::Parser
-  extend Forwardable
-
-  require 'puppet/parser/functions'
-  require 'puppet/parser/files'
-  require 'puppet/resource/type_collection'
-  require 'puppet/resource/type_collection_helper'
-  require 'puppet/resource/type'
-  require 'monitor'
-
-  AST = Puppet::Parser::AST
-
-  include Puppet::Resource::TypeCollectionHelper
-
-  attr_reader :version, :environment
-  attr_accessor :files
-
-  attr_accessor :lexer
-
-  # Add context to a message; useful for error messages and such.
-  def addcontext(message, obj = nil)
-    obj ||= @lexer
-
-    message += " on line #{obj.line}"
-    if file = obj.file
-      message += " in file #{file}"
-    end
-
-    message
-  end
-
-  # Create an AST array containing a single element
-  def aryfy(arg)
-    ast AST::ASTArray, :children => [arg]
-  end
-
-  # Create an AST block containing a single element
-  def block(arg)
-    ast AST::BlockExpression, :children => [arg]
-  end
-
-  # Create an AST object, and automatically add the file and line information if
-  # available.
-  def ast(klass, hash = {})
-    klass.new ast_context(klass.use_docs, hash[:line]).merge(hash)
-  end
-
-  def ast_context(include_docs = false, ast_line = nil)
-    result = {
-      :line => ast_line || lexer.line,
-      :file => lexer.file
-    }
-    result[:doc] = lexer.getcomment(result[:line]) if include_docs
-    result
-  end
-
-  # The fully qualifed name, with the full namespace.
-  def classname(name)
-    [@lexer.namespace, name].join("::").sub(/^::/, '')
-  end
-
-  def clear
-    initvars
-  end
-
-  # Raise a Parse error.
-  def error(message, options = {})
-    if @lexer.expected
-      message += "; expected '%s'"
-    end
-    except = Puppet::ParseError.new(message)
-    except.line = options[:line] || @lexer.line
-    except.file = options[:file] || @lexer.file
-
-    raise except
-  end
-
-  def_delegators :@lexer, :file, :string=
-
-  def file=(file)
-    unless Puppet::FileSystem.exist?(file)
-      unless file =~ /\.pp$/
-        file = file + ".pp"
-      end
-    end
-    raise Puppet::AlreadyImportedError, "Import loop detected for #{file}" if known_resource_types.watching_file?(file)
-
-    watch_file(file)
-    @lexer.file = file
-  end
-
-  def_delegators :known_resource_types, :hostclass, :definition, :node, :nodes?
-  def_delegators :known_resource_types, :find_hostclass, :find_definition
-  def_delegators :known_resource_types, :watch_file, :version
-
-  def import(file)
-    deprecation_location_text =
-    if @lexer.file && @lexer.line
-      " at #{@lexer.file}:#{@lexer.line}"
-    elsif @lexer.file
-      " in file #{@lexer.file}"
-    elsif @lexer.line
-      " at #{@lexer.line}"
-    end
-
-    Puppet.deprecation_warning("The use of 'import' is deprecated#{deprecation_location_text}. See http://links.puppetlabs.com/puppet-import-deprecation")
-    if @lexer.file
-      # use a path relative to the file doing the importing
-      dir = File.dirname(@lexer.file)
-    else
-      # otherwise assume that everything needs to be from where the user is
-      # executing this command. Normally, this would be in a "puppet apply -e"
-      dir = Dir.pwd
-    end
-
-    known_resource_types.loader.import(file, dir)
-  end
-
-  def initialize(env)
-    @environment = env
-    initvars
-  end
-
-  # Initialize or reset all of our variables.
-  def initvars
-    @lexer = Puppet::Parser::Lexer.new
-  end
-
-  # Split an fq name into a namespace and name
-  def namesplit(fullname)
-    ary = fullname.split("::")
-    n = ary.pop || ""
-    ns = ary.join("::")
-    return ns, n
-  end
-
-  def on_error(token,value,stack)
-    if token == 0 # denotes end of file
-      value = 'end of file'
-    else
-      value = "'#{value[:value]}'"
-    end
-    error = "Syntax error at #{value}"
-
-    if brace = @lexer.expected
-      error += "; expected '#{brace}'"
-    end
-
-    except = Puppet::ParseError.new(error)
-    except.line = @lexer.line
-    except.file = @lexer.file if @lexer.file
-
-    raise except
-  end
-
-  # how should I do error handling here?
-  def parse(string = nil)
-    if self.file =~ /\.rb$/
-      main = parse_ruby_file
-    else
-      self.string = string if string
-      begin
-        @yydebug = false
-        main = yyparse(@lexer,:scan)
-      rescue Puppet::ParseError => except
-        except.line ||= @lexer.line
-        except.file ||= @lexer.file
-        except.pos ||= @lexer.pos
-        raise except
-      rescue => except
-        raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, nil, except)
-      end
-    end
-    # Store the results as the top-level class.
-    return Puppet::Parser::AST::Hostclass.new('', :code => main)
-  ensure
-    @lexer.clear
-  end
-
-  def parse_ruby_file
-    Puppet.deprecation_warning("Use of the Ruby DSL is deprecated.")
-
-    # Execute the contents of the file inside its own "main" object so
-    # that it can call methods in the resource type API.
-    main_object = Puppet::DSL::ResourceTypeAPI.new
-    main_object.instance_eval(File.read(self.file))
-
-    # Then extract any types that were created.
-    Puppet::Parser::AST::BlockExpression.new :children => main_object.instance_eval { @__created_ast_objects__ }
-  end
-end

data/lib/puppet/pops/binder/lookup.rb

@@ -1,216 +0,0 @@
-# This class is the backing implementation of the Puppet function 'lookup'.
-# See puppet/parser/functions/lookup.rb for documentation.
-#
-class Puppet::Pops::Binder::Lookup
-
-  def self.parse_lookup_args(args)
-    options = {}
-    pblock = if args[-1].respond_to?(:puppet_lambda)
-      args.pop
-    end
-
-    case args.size
-    when 1
-      # name, or all options
-      if args[ 0 ].is_a?(Hash)
-        options = to_symbolic_hash(args[ 0 ])
-      else
-        options[ :name ] = args[ 0 ]
-      end
-
-    when 2
-      # name and type, or name and options
-      if args[ 1 ].is_a?(Hash)
-        options = to_symbolic_hash(args[ 1 ])
-        options[:name] = args[ 0 ] # silently overwrite option with given name
-      else
-        options[:name] = args[ 0 ]
-        options[:type] = args[ 1 ]
-      end
-
-    when 3
-      # name, type, default (no options)
-      options[ :name ] = args[ 0 ]
-      options[ :type ] = args[ 1 ]
-      options[ :default ] = args[ 2 ]
-    else
-      raise Puppet::ParseError, "The lookup function accepts 1-3 arguments, got #{args.size}"
-    end
-    options[:pblock] = pblock
-    options
-  end
-
-  def self.to_symbolic_hash(input)
-    names = [:name, :type, :default, :accept_undef, :extra, :override]
-    options = {}
-    names.each {|n| options[n] = undef_as_nil(input[n.to_s] || input[n]) }
-    options
-  end
-  private_class_method :to_symbolic_hash
-
-  def self.type_mismatch(type_calculator, expected, got)
-    "has wrong type, expected #{type_calculator.string(expected)}, got #{type_calculator.string(got)}"
-  end
-  private_class_method :type_mismatch
-
-  def self.fail(msg)
-    raise Puppet::ParseError, "Function lookup() " + msg
-  end
-  private_class_method :fail
-
-  def self.fail_lookup(names)
-    name_part = if names.size == 1
-      "the name '#{names[0]}'"
-    else
-      "any of the names ['" + names.join(', ') + "']"
-    end
-    fail("did not find a value for #{name_part}")
-  end
-  private_class_method :fail_lookup
-
-  def self.validate_options(options, type_calculator)
-    type_parser = Puppet::Pops::Types::TypeParser.new
-    name_type = type_parser.parse('Variant[Array[String], String]')
-
-    if is_nil_or_undef?(options[:name]) || options[:name].is_a?(Array) && options[:name].empty?
-      fail ("requires a name, or array of names. Got nothing to lookup.")
-    end
-
-    t = type_calculator.infer(options[:name])
-    if ! type_calculator.assignable?(name_type, t)
-      fail("given 'name' argument, #{type_mismatch(type_calculator, name_type, t)}")
-    end
-
-    # unless a type is already given (future case), parse the type (or default 'Data'), fails if invalid type is given
-    unless options[:type].is_a?(Puppet::Pops::Types::PAnyType)
-      options[:type] = type_parser.parse(options[:type] || 'Data')
-    end
-
-    # default value must comply with the given type
-    if options[:default]
-      t = type_calculator.infer(options[:default])
-      if ! type_calculator.assignable?(options[:type], t)
-        fail("'default' value #{type_mismatch(type_calculator, options[:type], t)}")
-      end
-    end
-
-    if options[:extra] && !options[:extra].is_a?(Hash)
-      # do not perform inference here, it is enough to know that it is not a hash
-      fail("'extra' value must be a Hash, got #{options[:extra].class}")
-    end
-    options[:extra] = {} unless options[:extra]
-
-    if options[:override] && !options[:override].is_a?(Hash)
-      # do not perform inference here, it is enough to know that it is not a hash
-      fail("'override' value must be a Hash, got #{options[:extra].class}")
-    end
-    options[:override] = {} unless options[:override]
-
-  end
-  private_class_method :validate_options
-
-  def self.nil_as_undef(x)
-    x.nil? ? :undef : x
-  end
-  private_class_method :nil_as_undef
-
-  def self.undef_as_nil(x)
-    is_nil_or_undef?(x) ? nil : x
-  end
-  private_class_method :undef_as_nil
-
-  def self.is_nil_or_undef?(x)
-    x.nil? || x == :undef
-  end
-  private_class_method :is_nil_or_undef?
-
-  # This is used as a marker - a value that cannot (at least not easily) by mistake be found in
-  # hiera data.
-  #
-  class PrivateNotFoundMarker; end
-
-  def self.search_for(scope, type, name, options)
-    # search in order, override, injector, hiera, then extra
-    if !(result = options[:override][name]).nil?
-      result
-    elsif !(result = scope.compiler.injector.lookup(scope, type, name)).nil?
-      result
-   else
-     result = call_hiera_function(scope, name, PrivateNotFoundMarker)
-     if !result.nil? && result != PrivateNotFoundMarker
-       result
-     else
-       options[:extra][name]
-     end
-   end
-  end
-  private_class_method :search_for
-
-  def self.call_hiera_function(scope, name, dflt)
-    loader = scope.compiler.loaders.private_environment_loader
-    func = loader.load(:function, :hiera) unless loader.nil?
-    raise Error, 'Function not found: hiera' if func.nil?
-    func.call(scope, name, dflt)
-  end
-  private_class_method :call_hiera_function
-
-    # This is the method called from the puppet/parser/functions/lookup.rb
-  # @param args [Array] array following the puppet function call conventions
-  def self.lookup(scope, args)
-    type_calculator = Puppet::Pops::Types::TypeCalculator.new
-    options = parse_lookup_args(args)
-    validate_options(options, type_calculator)
-    names = [options[:name]].flatten
-    type = options[:type]
-
-    result_with_name = names.reduce([]) do |memo, name|
-      break memo if !memo[1].nil?
-      [name, search_for(scope, type, name, options)]
-    end
-
-    result = if result_with_name[1].nil?
-      # not found, use default (which may be nil), the default is already type checked
-      options[:default]
-    else
-      # injector.lookup is type-safe already do no need to type check the result
-      result_with_name[1]
-    end
-
-    # If a block is given it is called with :undef passed as 'nil' since the lookup function
-    # is available from 3x with --binder turned on, and the evaluation is always 4x.
-    # TODO PUPPET4: Simply pass the value
-    #
-    result = if pblock = options[:pblock]
-      result2 = case pblock.parameter_count
-      when 1
-        pblock.call(undef_as_nil(result))
-      when 2
-        pblock.call(result_with_name[ 0 ], undef_as_nil(result))
-      else
-        pblock.call(result_with_name[ 0 ], undef_as_nil(result), undef_as_nil(options[ :default ]))
-      end
-
-      # if the given result was returned, there is no need to type-check it again
-      if !result2.equal?(result)
-        t = type_calculator.infer(undef_as_nil(result2))
-        if !type_calculator.assignable?(type, t)
-          fail "the value produced by the given code block #{type_mismatch(type_calculator, type, t)}"
-        end
-      end
-      result2
-    else
-      result
-    end
-
-    # Finally, the result if nil must be acceptable or an error is raised
-    if is_nil_or_undef?(result) && !options[:accept_undef]
-      fail_lookup(names)
-    else
-      # Since the function may be used without future parser being in effect, nil is not handled in a good
-      # way, and should instead be turned into :undef.
-      # TODO PUPPET4: Simply return the result
-      #
-      Puppet.future_parser? ? result : nil_as_undef(result)
-    end
-  end
-end

data/lib/puppet/pops/migration/migration_checker.rb

@@ -1,45 +0,0 @@
-# This class defines the private API of the MigrationChecker support.
-# @api private
-#
-class Puppet::Pops::Migration::MigrationChecker
-
-  def initialize()
-  end
-
-  # Produces a hash of available migrations; a map from a symbolic name in string form to a brief description.
-  def available_migrations()
-    { '3.8/4.0' => '3.8 future parser to 4.0 language migrations'}
-  end
-
-  # For 3.8/4.0
-  def report_ambiguous_integer(o)
-  end
-
-  # For 3.8/4.0
-  def report_ambiguous_float(o)
-  end
-
-  # For 3.8/4.0
-  def report_empty_string_true(value, o)
-  end
-
-  # For 3.8/4.0
-  def report_uc_bareword_type(value, o)
-  end
-
-  # For 3.8/4.0
-  def report_equality_type_mismatch(left, right, o)
-  end
-
-  # For 3.8/4.0
-  def report_option_type_mismatch(test_value, option_value, option_expr, matching_expr)
-  end
-
-  # For 3.8/4.0
-  def report_in_expression(o)
-  end
-
-  # For 3.8/4.0
-  def report_array_last_in_block(o)
-  end
-end