bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/pops.rb

@@ -1,121 +0,0 @@
-module Puppet
-  # The Pops language system. This includes the parser, evaluator, AST model, and
-  # Binder.
-  #
-  # @todo Explain how a user should use this to parse and evaluate the puppet
-  #   language.
-  #
-  # @note Warning: Pops is still considered experimental, as such the API may
-  #   change at any time.
-  #
-  # @api public
-  module Pops
-    EMPTY_HASH = {}.freeze
-    EMPTY_ARRAY = [].freeze
-    EMPTY_STRING = ''.freeze
-
-    MAX_INTEGER =  0x7fffffffffffffff
-    MIN_INTEGER = -0x8000000000000000
-
-    DOUBLE_COLON = '::'.freeze
-    USCORE = '_'.freeze
-
-    require 'semantic_puppet'
-
-    require 'puppet/pops/patterns'
-    require 'puppet/pops/utils'
-    require 'puppet/pops/puppet_stack'
-
-    require 'puppet/pops/adaptable'
-    require 'puppet/pops/adapters'
-
-    require 'puppet/pops/visitable'
-    require 'puppet/pops/visitor'
-
-    require 'puppet/pops/issues'
-    require 'puppet/pops/semantic_error'
-    require 'puppet/pops/label_provider'
-    require 'puppet/pops/validation'
-    require 'puppet/pops/issue_reporter'
-
-    require 'puppet/pops/time/timespan'
-    require 'puppet/pops/time/timestamp'
-
-    # (the Types module initializes itself)
-    require 'puppet/pops/types/types'
-    require 'puppet/pops/types/string_converter'
-    require 'puppet/pops/lookup'
-
-    require 'puppet/pops/merge_strategy'
-
-    module Model
-      require 'puppet/pops/model/ast'
-      require 'puppet/pops/model/tree_dumper'
-      require 'puppet/pops/model/ast_transformer'
-      require 'puppet/pops/model/factory'
-      require 'puppet/pops/model/model_tree_dumper'
-      require 'puppet/pops/model/model_label_provider'
-    end
-
-    module Resource
-      require 'puppet/pops/resource/resource_type_impl'
-    end
-    module Evaluator
-      require 'puppet/pops/evaluator/literal_evaluator'
-      require 'puppet/pops/evaluator/callable_signature'
-      require 'puppet/pops/evaluator/runtime3_converter'
-      require 'puppet/pops/evaluator/runtime3_resource_support'
-      require 'puppet/pops/evaluator/runtime3_support'
-      require 'puppet/pops/evaluator/evaluator_impl'
-      require 'puppet/pops/evaluator/epp_evaluator'
-      require 'puppet/pops/evaluator/collector_transformer'
-      require 'puppet/pops/evaluator/puppet_proc'
-      require 'puppet/pops/evaluator/deferred_resolver'
-      module Collectors
-        require 'puppet/pops/evaluator/collectors/abstract_collector'
-        require 'puppet/pops/evaluator/collectors/fixed_set_collector'
-        require 'puppet/pops/evaluator/collectors/catalog_collector'
-        require 'puppet/pops/evaluator/collectors/exported_collector'
-      end
-    end
-
-    module Parser
-      require 'puppet/pops/parser/eparser'
-      require 'puppet/pops/parser/parser_support'
-      require 'puppet/pops/parser/locator'
-      require 'puppet/pops/parser/locatable'
-      require 'puppet/pops/parser/lexer2'
-      require 'puppet/pops/parser/evaluating_parser'
-      require 'puppet/pops/parser/epp_parser'
-      require 'puppet/pops/parser/code_merger'
-    end
-
-    module Validation
-      require 'puppet/pops/validation/checker4_0'
-      require 'puppet/pops/validation/validator_factory_4_0'
-    end
-
-    # Subsystem for puppet functions defined in ruby.
-    #
-    # @api public
-    module Functions
-      require 'puppet/pops/functions/function'
-      require 'puppet/pops/functions/dispatch'
-      require 'puppet/pops/functions/dispatcher'
-    end
-
-    module Migration
-      require 'puppet/pops/migration/migration_checker'
-    end
-
-    module Serialization
-      require 'puppet/pops/serialization'
-    end
-  end
-
-  require 'puppet/parser/ast/pops_bridge'
-  require 'puppet/functions'
-  require 'puppet/datatypes'
-
-  Puppet::Pops::Model.register_pcore_types
-end

data/vendored/puppet/lib/puppet/pops/adaptable.rb

@@ -1,206 +0,0 @@
-# Adaptable is a mix-in module that adds adaptability to a class.
-# This means that an adapter can
-# associate itself with an instance of the class and store additional data/have behavior.
-#
-# This mechanism should be used when there is a desire to keep implementation concerns separate.
-# In Ruby it is always possible to open and modify a class or instance to teach it new tricks, but it
-# is however not possible to do this for two different versions of some service at the same time.
-# The Adaptable pattern is also good when only a few of the objects of some class needs to have extra
-# information (again possible in Ruby by adding instance variables dynamically). In fact, the implementation
-# of Adaptable does just that; it adds an instance variable named after the adapter class and keeps an
-# instance of this class in this slot.
-#
-# @note the implementation details; the fact that an instance variable is used to keep the adapter
-#   instance data should not
-#   be exploited as the implementation of _being adaptable_ may change in the future.
-# @api private
-#
-module Puppet::Pops
-module Adaptable
-  # Base class for an Adapter.
-  #
-  # A typical adapter just defines some accessors.
-  #
-  # A more advanced adapter may need to setup the adapter based on the object it is adapting.
-  # @example Making Duck adaptable
-  #   class Duck
-  #     include Puppet::Pops::Adaptable
-  #   end
-  # @example Giving a Duck a nick name
-  #   class NickNameAdapter < Puppet::Pops::Adaptable::Adapter
-  #     attr_accessor :nick_name
-  #   end
-  #   d = Duck.new
-  #   NickNameAdapter.adapt(d).nick_name = "Daffy"
-  #   NickNameAdapter.get(d).nick_name # => "Daffy"
-  #
-  # @example Giving a Duck a more elaborate nick name
-  #   class NickNameAdapter < Puppet::Pops::Adaptable::Adapter
-  #     attr_accessor :nick_name, :object
-  #     def initialize o
-  #       @object = o
-  #       @nick_name = "Yo"
-  #     end
-  #     def nick_name
-  #       "#{@nick_name}, the #{o.class.name}"
-  #     end
-  #     def NickNameAdapter.create_adapter(o)
-  #       x = new o
-  #       x
-  #     end
-  #   end
-  #   d = Duck.new
-  #   n = NickNameAdapter.adapt(d)
-  #   n.nick_name # => "Yo, the Duck"
-  #   n.nick_name = "Daffy"
-  #   n.nick_name # => "Daffy, the Duck"
-  # @example Using a block to set values
-  #   NickNameAdapter.adapt(o) { |a| a.nick_name = "Buddy!" }
-  #   NickNameAdapter.adapt(o) { |a, o| a.nick_name = "You're the best #{o.class.name} I met."}
-  #
-  class Adapter
-    # Returns an existing adapter for the given object, or nil, if the object is not
-    # adapted.
-    #
-    # @param o [Adaptable] object to get adapter from
-    # @return [Adapter<self>] an adapter of the same class as the receiver of #get
-    # @return [nil] if the given object o has not been adapted by the receiving adapter
-    # @raise [ArgumentError] if the object is not adaptable
-    #
-    def self.get(o)
-      attr_name = self_attr_name
-      if o.instance_variable_defined?(attr_name)
-        o.instance_variable_get(attr_name)
-      else
-        nil
-      end
-    end
-
-    # Returns an existing adapter for the given object, or creates a new adapter if the
-    # object has not been adapted, or the adapter has been cleared.
-    #
-    # @example Using a block to set values
-    #   NickNameAdapter.adapt(o) { |a| a.nick_name = "Buddy!" }
-    #   NickNameAdapter.adapt(o) { |a, o| a.nick_name = "Your the best #{o.class.name} I met."}
-    # @overload adapt(o)
-    # @overload adapt(o, {|adapter| block})
-    # @overload adapt(o, {|adapter, o| block})
-    # @param o [Adaptable] object to add adapter to
-    # @yieldparam adapter [Adapter<self>] the created adapter
-    # @yieldparam o [Adaptable] optional, the given adaptable
-    # @param block [Proc] optional, evaluated in the context of the adapter (existing or new)
-    # @return [Adapter<self>] an adapter of the same class as the receiver of the call
-    # @raise [ArgumentError] if the given object o is not adaptable
-    #
-    def self.adapt(o, &block)
-      attr_name = self_attr_name
-      adapter = if o.instance_variable_defined?(attr_name) && value = o.instance_variable_get(attr_name)
-        value
-      else
-        associate_adapter(create_adapter(o), o)
-      end
-      if block_given?
-        case block.arity
-          when 1
-            block.call(adapter)
-          else
-            block.call(adapter, o)
-        end
-      end
-      adapter
-    end
-
-    # Creates a new adapter, associates it with the given object and returns the adapter.
-    #
-    # @example Using a block to set values
-    #   NickNameAdapter.adapt_new(o) { |a| a.nick_name = "Buddy!" }
-    #   NickNameAdapter.adapt_new(o) { |a, o| a.nick_name = "Your the best #{o.class.name} I met."}
-    # This is used when a fresh adapter is wanted instead of possible returning an
-    # existing adapter as in the case of {Adapter.adapt}.
-    # @overload adapt_new(o)
-    # @overload adapt_new(o, {|adapter| block})
-    # @overload adapt_new(o, {|adapter, o| block})
-    # @yieldparam adapter [Adapter<self>] the created adapter
-    # @yieldparam o [Adaptable] optional, the given adaptable
-    # @param o [Adaptable] object to add adapter to
-    # @param block [Proc] optional, evaluated in the context of the new adapter
-    # @return [Adapter<self>] an adapter of the same class as the receiver of the call
-    # @raise [ArgumentError] if the given object o is not adaptable
-    #
-    def self.adapt_new(o, &block)
-      adapter = associate_adapter(create_adapter(o), o)
-      if block_given?
-        case block.arity
-        when 1
-          block.call(adapter)
-        else
-          block.call(adapter, o)
-        end
-      end
-      adapter
-    end
-
-    # Clears the adapter set in the given object o. Returns any set adapter or nil.
-    # @param o [Adaptable] the object where the adapter should be cleared
-    # @return [Adapter] if an adapter was set
-    # @return [nil] if the adapter has not been set
-    #
-    def self.clear(o)
-      attr_name = self_attr_name
-      if o.instance_variable_defined?(attr_name)
-        o.send(:remove_instance_variable, attr_name)
-      else
-        nil
-      end
-    end
-
-    # This base version creates an instance of the class (i.e. an instance of the concrete subclass
-    # of Adapter). A Specialization may want to create an adapter instance specialized for the given target
-    # object.
-    # @param o [Adaptable] The object to adapt. This implementation ignores this variable, but a
-    #   specialization may want to initialize itself differently depending on the object it is adapting.
-    # @return [Adapter<self>] instance of the subclass of Adapter receiving the call
-    #
-    def self.create_adapter(o)
-      new
-    end
-
-    # Associates the given adapter with the given target object
-    # @param adapter [Adapter] the adapter to associate with the given object _o_
-    # @param o [Adaptable] the object to adapt
-    # @return [adapter] the given adapter
-    #
-    def self.associate_adapter(adapter, o)
-      o.instance_variable_set(self_attr_name, adapter)
-      adapter
-    end
-
-    # Returns a suitable instance variable name given a class name.
-    # The returned string is the fully qualified name of a class with '::' replaced by '_' since
-    # '::' is not allowed in an instance variable name.
-    # @param name [String] the fully qualified name of a class
-    # @return [String] the name with all '::' replaced by '_'
-    # @api private
-    #
-    def self.instance_var_name(name)
-      name.split(DOUBLE_COLON).join(USCORE)
-    end
-
-    # Returns the name of the class, or the name of the type if the class represents an Object type
-    # @return [String] the name of the class or type
-    def self.type_name
-      self.name
-    end
-
-    # Returns a suitable instance variable name for the _name_ of this instance. The name is created by calling
-    # Adapter#instance_var_name and then cached.
-    # @return [String] the instance variable name for _name_
-    # @api private
-    #
-    def self.self_attr_name
-      @attr_name_sym ||= :"@#{instance_var_name(type_name)}"
-    end
-  end
-end
-end
-

data/vendored/puppet/lib/puppet/pops/adapters.rb

@@ -1,152 +0,0 @@
-# The Adapters module contains adapters for Documentation, Origin, SourcePosition, and Loader.
-#
-module Puppet::Pops
-module Adapters
-
-  class ObjectIdCacheAdapter < Puppet::Pops::Adaptable::Adapter
-    attr_accessor :cache
-
-    def initialize
-      @cache = {}
-    end
-
-    # Retrieves a mutable hash with all stored values
-    def retrieve(o)
-      @cache[o.__id__] ||= {}
-    end
-  end
-
-  # A documentation adapter adapts an object with a documentation string.
-  # (The intended use is for a source text parser to extract documentation and store this
-  # in DocumentationAdapter instances).
-  #
-  class DocumentationAdapter < Adaptable::Adapter
-    # @return [String] The documentation associated with an object
-    attr_accessor :documentation
-  end
-
-  # An  empty alternative adapter is used when there is the need to
-  # attach a value to be used if the original is empty. This is used
-  # when a lazy evaluation takes place, and the decision how to handle an
-  # empty case must be delayed.
-  #
-  class EmptyAlternativeAdapter < Adaptable::Adapter
-    # @return [Object] The alternative value associated with an object
-    attr_accessor :empty_alternative
-  end
-
-  # This class is for backward compatibility only. It's not really an adapter but it is
-  # needed for the puppetlabs-strings gem
-  # @deprecated
-  class SourcePosAdapter
-    def self.adapt(object)
-      new(object)
-    end
-
-    def initialize(object)
-      @object = object
-    end
-
-    def file
-      @object.file
-    end
-
-    def line
-      @object.line
-    end
-
-    def pos
-      @object.pos
-    end
-
-    def extract_text
-      @object.locator.extract_text(@object.offset, @object.length)
-    end
-  end
-
-  # A LoaderAdapter adapts an object with a {Loader}. This is used to make further loading from the
-  # perspective of the adapted object take place in the perspective of this Loader.
-  #
-  # It is typically enough to adapt the root of a model as a search is made towards the root of the model
-  # until a loader is found, but there is no harm in duplicating this information provided a contained
-  # object is adapted with the correct loader.
-  #
-  # @see Utils#find_adapter
-  # @api private
-  class LoaderAdapter < Adaptable::Adapter
-    attr_accessor :loader_name
-
-    # Finds the loader to use when loading originates from the source position of the given argument.
-    #
-    # @param instance [Model::PopsObject] The model object
-    # @param file [String] the file from where the model was parsed
-    # @param default_loader [Loader] the loader to return if no loader is found for the model
-    # @return [Loader] the found loader or default_loader if it could not be found
-    #
-    def self.loader_for_model_object(model, file = nil, default_loader = nil)
-      loaders = Puppet.lookup(:loaders) { nil }
-      if loaders.nil?
-        default_loader || Loaders.static_loader
-      else
-        loader_name = loader_name_by_source(loaders.environment, model, file)
-        if loader_name.nil?
-          default_loader || loaders[Loader::ENVIRONMENT_PRIVATE]
-        else
-          loaders[loader_name]
-        end
-      end
-    end
-
-    class PathsAndNameCacheAdapter < Puppet::Pops::Adaptable::Adapter
-      attr_accessor :cache, :paths
-    end
-
-    # Attempts to find the module that `instance` originates from by looking at it's {SourcePosAdapter} and
-    # compare the `locator.file` found there with the module paths given in the environment found in the
-    # given `scope`. If the file is found to be relative to a path, then the first segment of the relative
-    # path is interpreted as the name of a module. The object that the {SourcePosAdapter} is adapted to
-    # will then be adapted to the private loader for that module and that adapter is returned.
-    #
-    # The method returns `nil` when no module could be found.
-    #
-    # @param environment [Puppet::Node::Environment] the current environment
-    # @param instance [Model::PopsObject] the AST for the code
-    # @param file [String] the path to the file for the code or `nil`
-    # @return [String] the name of the loader associated with the source
-    # @api private
-    def self.loader_name_by_source(environment, instance, file)
-      file = instance.file if file.nil?
-      return nil if file.nil? || EMPTY_STRING == file
-      pn_adapter = PathsAndNameCacheAdapter.adapt(environment) do |a|
-        a.paths ||= environment.modulepath.map { |p| Pathname.new(p) }
-        a.cache ||= {}
-      end
-      dir = File.dirname(file)
-      pn_adapter.cache.fetch(dir) do |key|
-        mod = find_module_for_dir(environment, pn_adapter.paths, dir)
-        loader_name = mod.nil? ? nil : "#{mod.name} private"
-        pn_adapter.cache[key] = loader_name
-      end
-    end
-
-    # @api private
-    def self.find_module_for_dir(environment, paths, dir)
-      return nil if dir.nil?
-      file_path = Pathname.new(dir)
-      paths.each do |path|
-        begin
-          relative_path = file_path.relative_path_from(path).to_s.split(File::SEPARATOR)
-        rescue ArgumentError
-          # file_path was not relative to the module_path. That's OK.
-          next
-        end
-        if relative_path.length > 1
-          mod = environment.module(relative_path[0])
-          return mod unless mod.nil?
-        end
-      end
-      nil
-    end
-  end
-end
-end