bolt 0.0.1 → 0.5.0

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

@@ -0,0 +1,116 @@
+require 'json'
+
+module Puppet::Pops
+module Types
+  # Ruby implementation of the Task Pcore type. It is the super type of a custom task that either has parameters
+  # or explicitly declared that it has zero parameters (by providing an empty parameters clause).
+  class Task
+    include PuppetObject
+
+    # Pattern used for task parameter names
+    PARAMETER_NAME_PATTERN = PPatternType.new([PRegexpType.new(/\A[a-z][a-z0-9_]*\z/)])
+
+    # Register the Task type with the Pcore loader and implementation registry
+    def self.register_ptype(loader, ir)
+      @type = Pcore::create_object_type(loader, ir, self, 'Task', nil, {
+        'supports_noop' => {
+          'type' => PBooleanType::DEFAULT,
+          'value' => false,
+          'kind' => 'constant'
+        },
+        'input_method' => {
+          'type' => PStringType::DEFAULT,
+          'value' => 'both',
+          'kind' => 'constant'
+        },
+        'executable' => {
+          'type' => PStringType::DEFAULT,
+          'kind' => 'constant',
+          'value' => ''
+        },
+        'task_json' => {
+          'type' => PStringType::DEFAULT,
+          'kind' => 'derived'
+        },
+      })
+    end
+
+    def self._pcore_type
+      @type
+    end
+
+    # Calculates the full path of the executable file. It is required that the type was loaded
+    # using a file based loader
+    # @return [String] The full path to the executable.
+    def executable_path
+      loader = _pcore_type.loader
+      unless loader.is_a?(Loader::ModuleLoaders::FileBased)
+        raise Puppet::Error,
+          _('Absolute path of executable %{file} for task %{task} cannot be determined. This type was not loaded by a file based loader') %
+          { :filename => executable, :task => _pcore_type.name }
+      end
+      File.join(loader.path, 'tasks', executable)
+    end
+
+    # Returns the parameters of this instance represented as a JSON string
+    # @return [String] the JSON string representation of all parameter values
+    def task_json
+      # Convert this instance into Data and strip off the __pcore_type__ key. It's not
+      # needed when executing the task
+      rich_json = Serialization::ToDataConverter.convert(self, :rich_data => true)
+      rich_json.delete('__pcore_type__')
+      rich_json.to_json
+    end
+
+    # Returns the parameters of this instance as a Hash
+    # @return [Hash] a map of attribute names to values as given when the instance of Task was created
+    #
+    def task_args()
+      _pcore_init_hash
+    end
+  end
+
+  # Ruby implementation of the GenericTask. It is a specialization of the Task Pcore type used as the super type
+  # of custom task that lacks a 'parameters' definition (or lacks metadata altogether). This task accepts any
+  # parameters and keeps them in an 'args' hash.
+  class GenericTask < Task
+    # Register the GenericTask type with the Pcore loader and implementation registry
+    def self.register_ptype(loader, ir)
+      @type = Pcore::create_object_type(loader, ir, self, 'GenericTask', 'Task', {
+        'args' => {
+          'type' => PHashType.new(PARAMETER_NAME_PATTERN, PTypeReferenceType.new('Data')),
+          'value' => EMPTY_HASH
+        }
+      })
+    end
+
+    def self._pcore_type
+      @type
+    end
+
+    attr_reader :args
+
+    def _pcore_init_hash
+      { 'args' => args }
+    end
+
+    def initialize(args = EMPTY_HASH)
+      @args = args
+    end
+
+    def task_json
+      @args.to_json
+    end
+
+    def task_args()
+      args
+    end
+
+    # Special to_s needed to cloak the 'attr' attribute and instead present
+    # the hash
+    def to_s
+      "#{_pcore_type.name}(#{TypeFormatter.string(@args)})"
+    end
+  end
+end
+end

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

@@ -0,0 +1,250 @@
+module Puppet::Pops::Types
+module Iterable
+
+class TreeIterator
+  include Iterable
+
+  DEFAULT_CONTAINERS = TypeFactory.variant(
+    PArrayType::DEFAULT,
+    PHashType::DEFAULT,
+    PObjectType::DEFAULT
+    )
+
+  # Creates a TreeIterator that by default treats all Array, Hash and Object instances as
+  # containers - the 'containers' option can be set to a type that denotes which types of values
+  # should be treated as containers - a `Variant[Array, Hash]` would for instance not treat
+  # Object values as containers, whereas just `Object` would only treat objects as containers.
+  #
+  # Unrecognized options are silently ignored
+  #
+  # @param [Hash] options the options
+  # @option options [PTypeType] :container_type ('Variant[Hash, Array, Object]') The type(s) that should be treated as containers. The
+  #   given type(s) must be assignable to the default container_type.
+  # @option options [Boolean] :include_root ('true') If the root container itself should be included in the iteration (requires
+  #   `include_containers` to also be `true` to take effect).
+  # @option options [Boolean] :include_containers ('true') If containers should be included in the iteration
+  # @option options [Boolean] :include_values ('true') If non containers (values) should be included in the iteration
+  # @option options [Boolean] :include_refs ('false') If (non containment) referenced values in Objects should be included 
+  #
+  def initialize(enum, options=EMPTY_HASH)
+    @root = enum
+    @element_t = nil
+    @value_stack = [enum]
+    @indexer_stack = []
+    @current_path = []
+    @recursed = false
+    @containers_t = options['container_type'] || DEFAULT_CONTAINERS
+    unless DEFAULT_CONTAINERS.assignable?(@containers_t)
+      raise ArgumentError, _("Only Array, Hash, and Object types can be used as container types. Got %{type}") % {type: @containers_t}
+    end
+    @with_root       = extract_option(options, 'include_root', true)
+    @with_containers = extract_option(options, 'include_containers', true)
+    @with_values     = extract_option(options, 'include_values', true)
+    @with_root       = @with_containers && extract_option(options, 'include_root', true)
+    unless @with_containers || @with_values
+      raise ArgumentError, _("Options 'include_containers' and 'include_values' cannot both be false")
+    end
+    @include_refs = !!options['include_refs']
+  end
+
+  # Yields each `path, value` if the block arity is 2, and only `value` if arity is 1
+  #
+  def each(&block)
+    loop do
+      if block.arity == 1
+        yield(self.next)
+      else
+        yield(*self.next)
+      end
+    end
+  end
+
+  def size
+    raise "Not yet implemented - computes size lazily"
+  end
+
+  def unbounded?
+    false
+  end
+
+  def to_array
+    result = []
+    loop do
+      result << self.next
+    end
+    result
+  end
+
+  def reverse_each(&block)
+    r = Iterator.new(PAnyType::DEFAULT, to_array.reverse_each)
+    block_given? ? r.each(&block) : r
+  end
+
+  def step(step, &block)
+    r = StepIterator.new(PAnyType::DEFAULT, self, step)
+    block_given? ? r.each(&block) : r
+  end
+
+  def indexer_on(val)
+    return nil unless @containers_t.instance?(val)
+    if val.is_a?(Array)
+      val.size.times
+    elsif val.is_a?(Hash)
+      val.each_key
+    else
+      if @include_refs
+        val._pcore_type.attributes.each_key
+      else
+        val._pcore_type.attributes.reject {|k,v| v.kind == PObjectType::ATTRIBUTE_KIND_REFERENCE }.each_key
+      end
+    end
+  end
+  private :indexer_on
+
+  def has_next?(iterator)
+    begin
+      iterator.peek
+      true
+    rescue StopIteration
+      false
+    end
+  end
+  private :has_next?
+
+  def extract_option(options, key, default)
+    v = options[key]
+    v.nil? ? default : !!v
+  end
+  private :extract_option
+end
+
+class DepthFirstTreeIterator < TreeIterator
+
+  # Creates a DepthFirstTreeIterator that by default treats all Array, Hash and Object instances as
+  # containers - the 'containers' option can be set to a type that denotes which types of values
+  # should be treated as containers - a `Variant[Array, Hash]` would for instance not treat
+  # Object values as containers, whereas just `Object` would only treat objects as containers.
+  #
+  # @param [Hash] options the options
+  # @option options [PTypeType] :containers ('Variant[Hash, Array, Object]') The type(s) that should be treated as containers
+  # @option options [Boolean] :with_root ('true') If the root container itself should be included in the iteration
+  #
+  def initialize(enum, options = EMPTY_HASH)
+    super
+  end
+
+  def next
+    loop do
+      break if @value_stack.empty?
+
+      # first call
+      if @indexer_stack.empty?
+        @indexer_stack << indexer_on(@root)
+        @recursed = true
+        return [[], @root] if @with_root
+      end
+
+      begin
+        if @recursed
+          @current_path << nil
+          @recursed = false
+        end
+        idx = @indexer_stack[-1].next
+        @current_path[-1] = idx
+        v = @value_stack[-1]
+        value = v.is_a?(PuppetObject) ? v.send(idx) : v[idx]
+        indexer = indexer_on(value)
+        if indexer
+          # recurse
+          @recursed = true
+          @value_stack << value
+          @indexer_stack << indexer
+          redo unless @with_containers
+        else
+          redo unless @with_values
+        end
+        return [@current_path.dup, value]
+
+      rescue StopIteration
+        # end of current value's range of content
+        # pop all until out of next values
+        at_the_very_end = false
+        loop do
+          pop_level
+          at_the_very_end = @indexer_stack.empty?
+          break if at_the_very_end || has_next?(@indexer_stack[-1])
+        end
+      end
+    end
+    raise StopIteration
+  end
+
+  def pop_level
+    @value_stack.pop
+    @indexer_stack.pop
+    @current_path.pop
+  end
+  private :pop_level
+end
+
+class BreadthFirstTreeIterator < TreeIterator
+  def initialize(enum, options = EMPTY_HASH)
+    @path_stack = []
+    super
+  end
+
+  def next
+    loop do
+      break if @value_stack.empty?
+
+      # first call
+      if @indexer_stack.empty?
+        @indexer_stack << indexer_on(@root)
+        @recursed = true
+        return [[], @root] if @with_root
+      end
+
+      begin
+        if @recursed
+          @current_path << nil
+          @recursed = false
+        end
+
+        idx = @indexer_stack[0].next
+        @current_path[-1] = idx
+        v = @value_stack[0]
+        value = v.is_a?(PuppetObject) ? v.send(idx) : v[idx]
+        indexer = indexer_on(value)
+        if indexer
+          @value_stack << value
+          @indexer_stack << indexer
+          @path_stack << @current_path.dup
+          next unless @with_containers
+        end
+        return [@current_path.dup, value]
+
+      rescue StopIteration
+        # end of current value's range of content
+        # shift all until out of next values
+        at_the_very_end = false
+        loop do
+          shift_level
+          at_the_very_end = @indexer_stack.empty?
+          break if at_the_very_end || has_next?(@indexer_stack[0])
+        end
+      end
+    end
+    raise StopIteration
+  end
+
+  def shift_level
+    @value_stack.shift
+    @indexer_stack.shift
+    @current_path = @path_stack.shift
+    @recursed = true
+  end
+  private :shift_level
+
+end
+end
+end

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

@@ -0,0 +1,25 @@
+module Puppet::Pops
+module Types
+# Implements a standard visitor patter for the Puppet Type system.
+
+#
+# An instance of this module is passed as an argument to the {PAnyType#accept}
+# method of a Type instance. That type will then use the {TypeAcceptor#visit} callback
+# on the acceptor and then pass the acceptor to the `accept` method of all contained
+# type instances so that the it gets a visit from each one recursively.
+#
+module TypeAcceptor
+  # @param type [PAnyType] the type that we accept a visit from
+  # @param quard [RecursionGuard] the guard against self recursion
+  def visit(type, guard)
+  end
+end
+
+# An acceptor that does nothing
+class NoopTypeAcceptor
+  include TypeAcceptor
+
+  INSTANCE = NoopTypeAcceptor.new
+end
+end
+end

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

@@ -0,0 +1,47 @@
+# Utility module for type assertion
+#
+module Puppet::Pops::Types
+module TypeAsserter
+  # Asserts that a type_to_check is assignable to required_type and raises
+  # a {Puppet::ParseError} if that's not the case
+  #
+  # @param subject [String,Array] String to be prepended to the exception message or Array where the first element is
+  #   a format string and the rest are arguments to that format string
+  # @param expected_type [PAnyType] Expected type
+  # @param type_to_check [PAnyType] Type to check against the required type
+  # @return The type_to_check argument
+  #
+  # @api public
+  def self.assert_assignable(subject, expected_type, type_to_check, &block)
+    report_type_mismatch(subject, expected_type, type_to_check, 'is incorrect', &block) unless expected_type.assignable?(type_to_check)
+    type_to_check
+  end
+
+  # Asserts that a value is an instance of a given type and raises
+  # a {Puppet::ParseError} if that's not the case
+  #
+  # @param subject [String,Array] String to be prepended to the exception message or Array where the first element is
+  #                               a format string and the rest are arguments to that format string
+  # @param expected_type [PAnyType] Expected type for the value
+  # @param value [Object] Value to check
+  # @param nil_ok [Boolean] Can be true to allow nil value. Optional and defaults to false
+  # @return The value argument
+  #
+  # @api public
+  def self.assert_instance_of(subject, expected_type, value, nil_ok = false, &block)
+    unless value.nil? && nil_ok
+      report_type_mismatch(subject, expected_type, TypeCalculator.singleton.infer_set(value), &block) unless expected_type.instance?(value)
+    end
+    value
+  end
+
+  def self.report_type_mismatch(subject, expected_type, actual_type, what = 'has wrong type')
+    subject = yield(subject) if block_given?
+    subject = subject[0] % subject[1..-1] if subject.is_a?(Array)
+    raise TypeAssertionError.new(
+      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} #{what},", expected_type, actual_type), expected_type, actual_type)
+  end
+  private_class_method :report_type_mismatch
+end
+end
+

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

@@ -0,0 +1,27 @@
+
+module Puppet::Pops::Types
+  # Raised when an assertion of actual type against an expected type fails.
+  #
+  class TypeAssertionError < Puppet::Error
+
+    # Returns the expected type
+    # @return [PAnyType] expected type
+    attr_reader :expected_type
+
+    # Returns the actual type
+    # @return [PAnyType] actual type
+    attr_reader :actual_type
+
+    # Creates a new instance with a default message, expected, and actual types,
+    #
+    # @param message [String] The default message
+    # @param expected_type [PAnyType] The expected type
+    # @param actual_type [PAnyType] The actual type
+    #
+    def initialize(message, expected_type, actual_type)
+      super(message)
+      @expected_type = expected_type
+      @actual_type = actual_type
+    end
+  end
+end