bolt 0.24.0 → 0.25.0

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

@@ -1,234 +0,0 @@
-module Puppet::Pops
-module Evaluator
-class CollectorTransformer
-
-  def initialize
-    @@query_visitor    ||= Visitor.new(nil, "query", 1, 1)
-    @@match_visitor    ||= Visitor.new(nil, "match", 1, 1)
-    @@evaluator        ||= EvaluatorImpl.new
-    @@compare_operator ||= CompareOperator.new()
-  end
-
-  def transform(o, scope)
-    #TRANSLATORS 'CollectExpression' is a class name and should not be translated
-    raise ArgumentError, _("Expected CollectExpression") unless o.is_a? Model::CollectExpression
-
-    raise "LHS is not a type" unless o.type_expr.is_a? Model::QualifiedReference
-    type = o.type_expr.value().downcase()
-
-    if type == 'class'
-      fail "Classes cannot be collected"
-    end
-
-    resource_type = Runtime3ResourceSupport.find_resource_type(scope, type)
-
-    fail "Resource type #{type} doesn't exist" unless resource_type
-
-    if !o.operations.empty?
-      overrides = {
-        :parameters => o.operations.map{ |x| @@evaluator.evaluate(x, scope)}.flatten,
-        :file       => o.file,
-        :line       => o.line,
-        :source     => scope.source,
-        :scope      => scope
-      }
-    end
-
-    code = query_unless_nop(o.query, scope)
-
-    case o.query
-    when Model::VirtualQuery
-      newcoll = Collectors::CatalogCollector.new(scope, resource_type, code, overrides)
-    when Model::ExportedQuery
-      match = match_unless_nop(o.query, scope)
-      newcoll = Collectors::ExportedCollector.new(scope, resource_type, match, code, overrides)
-    end
-
-    scope.compiler.add_collection(newcoll)
-
-    newcoll
-  end
-
-protected
-
-  def query(o, scope)
-    @@query_visitor.visit_this_1(self, o, scope)
-  end
-
-  def match(o, scope)
-    @@match_visitor.visit_this_1(self, o, scope)
-  end
-
-  def query_unless_nop(query, scope)
-    unless query.expr.nil? || query.expr.is_a?(Model::Nop)
-      query(query.expr, scope)
-    end
-  end
-
-  def match_unless_nop(query, scope)
-    unless query.expr.nil? || query.expr.is_a?(Model::Nop)
-      match(query.expr, scope)
-    end
-  end
-
-  def query_AndExpression(o, scope)
-    left_code = query(o.left_expr, scope)
-    right_code = query(o.right_expr, scope)
-    proc do |resource|
-      left_code.call(resource) && right_code.call(resource)
-    end
-  end
-
-  def query_OrExpression(o, scope)
-    left_code = query(o.left_expr, scope)
-    right_code = query(o.right_expr, scope)
-    proc do |resource|
-      left_code.call(resource) || right_code.call(resource)
-    end
-  end
-
-  def query_ComparisonExpression(o, scope)
-    left_code = query(o.left_expr, scope)
-    right_code = query(o.right_expr, scope)
-
-    case o.operator
-    when '=='
-      if left_code == "tag"
-        # Ensure that to_s and downcase is done once, i.e. outside the proc block and
-        # then use raw_tagged? instead of tagged?
-        if right_code.is_a?(Array)
-          tags = right_code
-        else
-          tags = [ right_code ]
-        end
-        tags = tags.collect do |t|
-          raise ArgumentError, _('Cannot transform a number to a tag') if t.is_a?(Numeric)
-          t.to_s.downcase
-        end
-        proc do |resource|
-          resource.raw_tagged?(tags)
-        end
-      else
-        proc do |resource|
-          if (tmp = resource[left_code]).is_a?(Array)
-            @@compare_operator.include?(tmp, right_code, scope)
-          else
-            @@compare_operator.equals(tmp, right_code)
-          end
-        end
-      end
-    when '!='
-      proc do |resource|
-        !@@compare_operator.equals(resource[left_code], right_code)
-      end
-    end
-  end
-
-  def query_AccessExpression(o, scope)
-    pops_object = @@evaluator.evaluate(o, scope)
-
-    # Convert to Puppet 3 style objects since that is how they are represented
-    # in the catalog.
-    @@evaluator.convert(pops_object, scope, nil)
-  end
-
-  def query_VariableExpression(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def query_LiteralBoolean(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def query_LiteralString(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def query_ConcatenatedString(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def query_LiteralNumber(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def query_LiteralUndef(o, scope)
-    nil
-  end
-
-  def query_QualifiedName(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def query_ParenthesizedExpression(o, scope)
-   query(o.expr, scope)
-  end
-
-  def query_Object(o, scope)
-    raise ArgumentError, _("Cannot transform object of class %{klass}") % { klass: o.class }
-  end
-
-  def match_AccessExpression(o, scope)
-    pops_object = @@evaluator.evaluate(o, scope)
-
-    # Convert to Puppet 3 style objects since that is how they are represented
-    # in the catalog.
-    @@evaluator.convert(pops_object, scope, nil)
-  end
-
-  def match_AndExpression(o, scope)
-    left_match = match(o.left_expr, scope)
-    right_match = match(o.right_expr, scope)
-    return [left_match, 'and', right_match]
-  end
-
-  def match_OrExpression(o, scope)
-    left_match = match(o.left_expr, scope)
-    right_match = match(o.right_expr, scope)
-    return [left_match, 'or', right_match]
-  end
-
-  def match_ComparisonExpression(o, scope)
-    left_match = match(o.left_expr, scope)
-    right_match = match(o.right_expr, scope)
-    return [left_match, o.operator.to_s, right_match]
-  end
-
-  def match_VariableExpression(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def match_LiteralBoolean(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def match_LiteralString(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def match_LiteralUndef(o, scope)
-    nil
-  end
-
-  def match_ConcatenatedString(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def match_LiteralNumber(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def match_QualifiedName(o, scope)
-    @@evaluator.evaluate(o, scope)
-  end
-
-  def match_ParenthesizedExpression(o, scope)
-   match(o.expr, scope)
-  end
-
-  def match_Object(o, scope)
-    raise ArgumentError, _("Cannot transform object of class %{klass}") % { klass: o.class }
-  end
-end
-end
-end

data/vendored/puppet/lib/puppet/pops/evaluator/collectors/abstract_collector.rb

@@ -1,86 +0,0 @@
-class Puppet::Pops::Evaluator::Collectors::AbstractCollector
-  attr_reader :scope
-
-  # The collector's hash of overrides {:parameters => params}
-  attr_reader :overrides
-
-  # The set of collected resources
-  attr_reader :collected
-
-  # An empty array which will be returned by the unresolved_resources
-  # method unless we have a FixSetCollector
-  EMPTY_RESOURCES = [].freeze
-
-  # Initialized the instance variables needed by the base
-  # collector class to perform evaluation
-  #
-  # @param [Puppet::Parser::Scope] scope
-  #
-  # @param [Hash] overrides a hash of optional overrides
-  # @options opts [Array] :parameters
-  # @options opts [String] :file
-  # @options opts [Array] :line
-  # @options opts [Puppet::Resource::Type] :source
-  # @options opts [Puppet::Parser::Scope] :scope
-  def initialize(scope, overrides = nil)
-    @collected = {}
-    @scope = scope
-
-    if !(overrides.nil? || overrides[:parameters])
-      raise ArgumentError, _("Exported resource try to override without parameters")
-    end
-
-    @overrides = overrides
-  end
-
-  # Collects resources and marks collected objects as non-virtual. Also
-  # handles overrides.
-  #
-  # @return [Array] the resources we have collected
-  def evaluate
-    objects = collect.each do |obj|
-      obj.virtual = false
-    end
-
-    return false if objects.empty?
-
-    if @overrides and !objects.empty?
-      overrides[:source].meta_def(:child_of?) do |klass|
-        true
-      end
-
-      objects.each do |res|
-        unless @collected.include?(res.ref)
-          newres = Puppet::Parser::Resource.new(res.type, res.title, @overrides)
-          scope.compiler.add_override(newres)
-        end
-      end
-    end
-
-    objects.reject! { |o| @collected.include?(o.ref) }
-
-    return false if objects.empty?
-
-    objects.reduce(@collected) { |c,o| c[o.ref]=o; c }
-
-    objects
-  end
-
-  # This should only return an empty array unless we have
-  # an FixedSetCollector, in which case it will return the
-  # resources that have not yet been realized
-  #
-  # @return [Array] the resources that have not been resolved
-  def unresolved_resources
-    EMPTY_RESOURCES
-  end
-
-  # Collect the specified resources. The way this is done depends on which type
-  # of collector we are dealing with. This method is implemented differently in
-  # each of the three child classes
-  #
-  # @return [Array] the collected resources
-  def collect
-    raise NotImplementedError, "This method must be implemented by the child class"
-  end
-end

data/vendored/puppet/lib/puppet/pops/evaluator/collectors/catalog_collector.rb

@@ -1,29 +0,0 @@
-class Puppet::Pops::Evaluator::Collectors::CatalogCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
-
-  # Creates a CatalogCollector using the AbstractCollector's 
-  # constructor to set the scope and overrides
-  #
-  # param [Puppet::CompilableResourceType] type the resource type to be collected
-  # param [Proc] query the query which defines which resources to match
-  def initialize(scope, type, query, overrides = nil)
-    super(scope, overrides)
-
-    @query = query
-
-    @type = Puppet::Resource.new(type, 'whatever').type
-  end
-
-  # Collects virtual resources based off a collection in a manifest
-  def collect
-    t = @type
-    q = @query
-
-    scope.compiler.resources.find_all do |resource|
-      resource.type == t && (q ?  q.call(resource) : true)
-    end
-  end
-
-  def to_s
-    "Catalog-Collector[#{@type.to_s}]"
-  end
-end

data/vendored/puppet/lib/puppet/pops/evaluator/collectors/exported_collector.rb

@@ -1,69 +0,0 @@
-class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
-
-  # Creates an ExportedCollector using the AbstractCollector's
-  # constructor to set the scope and overrides
-  #
-  # param [Puppet::CompilableResourceType] type the resource type to be collected
-  # param [Array] equery an array representation of the query (exported query)
-  # param [Proc] cquery a proc representation of the query (catalog query)
-  def initialize(scope, type, equery, cquery, overrides = nil)
-    super(scope, overrides)
-
-    @equery = equery
-    @cquery = cquery
-
-    @type = Puppet::Resource.new(type, 'whatever').type
-  end
-
-  # Ensures that storeconfigs is present before calling AbstractCollector's
-  # evaluate method
-  def evaluate
-    if Puppet[:storeconfigs] != true
-      return false
-    end
-
-    super
-  end
-
-  # Collect exported resources as defined by an exported
-  # collection. Used with PuppetDB
-  def collect
-    resources = []
-
-    time = Puppet::Util.thinmark do
-      t = @type
-      q = @cquery
-
-      resources = scope.compiler.resources.find_all do |resource|
-        resource.type == t && resource.exported? && (q.nil? || q.call(resource))
-      end
-
-      found = Puppet::Resource.indirection.
-        search(@type, :host => @scope.compiler.node.name, :filter => @equery, :scope => @scope)
-
-      found_resources = found.map {|x| x.is_a?(Puppet::Parser::Resource) ? x : x.to_resource(@scope)}
-
-      found_resources.each do |item|
-        if existing = @scope.findresource(item.resource_type, item.title)
-          unless existing.collector_id == item.collector_id
-            raise Puppet::ParseError,
-              _("A duplicate resource was found while collecting exported resources, with the type and title %{title}") % { title: item.ref }
-          end
-        else
-          item.exported = false
-          @scope.compiler.add_resource(@scope, item)
-          resources << item
-        end
-      end
-    end
-
-    scope.debug("Collected %s %s resource%s in %.2f seconds" %
-                [resources.length, @type, resources.length == 1 ? "" : "s", time])
-
-    resources
-  end
-
-  def to_s
-    "Exported-Collector[#{@type.to_s}]"
-  end
-end

data/vendored/puppet/lib/puppet/pops/evaluator/collectors/fixed_set_collector.rb

@@ -1,37 +0,0 @@
-class Puppet::Pops::Evaluator::Collectors::FixedSetCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
-
-  # Creates a FixedSetCollector using the AbstractCollector constructor
-  # to set the scope. It is not possible for a collection to have
-  # overrides in this case, since we have a fixed set of resources that
-  # can be different types.
-  #
-  # @param [Array] resources the fixed set of resources we want to realize
-  def initialize(scope, resources)
-    super(scope)
-    @resources = resources.is_a?(Array)? resources.dup : [resources]
-  end
-
-  # Collects a fixed set of resources and realizes them. Used
-  # by the realize function
-  def collect
-    resolved = []
-    result = @resources.reduce([]) do |memo, ref|
-      if res = @scope.findresource(ref.to_s)
-        res.virtual = false
-        memo << res
-        resolved << ref
-      end
-      memo
-    end
-
-    @resources = @resources - resolved
-
-    @scope.compiler.delete_collection(self) if @resources.empty?
-
-    result
-  end
-
-  def unresolved_resources
-    @resources
-  end
-end