puppet 4.4.2-x64-mingw32 → 4.5.0-x64-mingw32

data/lib/puppet/parser/environment_compiler.rb

@@ -1,13 +1,13 @@
 require 'puppet/parser/compiler'
 
 class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
-  def self.compile(env)
+  def self.compile(env, code_id=nil)
     begin
       env.check_for_reparse
 
       node = Puppet::Node.new(env)
       node.environment = env
-      new(node).compile
+      new(node, :code_id => code_id).compile
     rescue => detail
       message = "#{detail} in environment #{env.name}"
       Puppet.log_exception(detail, message)

data/lib/puppet/parser/resource.rb

@@ -182,11 +182,20 @@ class Puppet::Parser::Resource < Puppet::Resource
   alias []= set_parameter
 
   def to_hash
-    @parameters.inject({}) do |hash, ary|
-      param = ary[1]
-      # Skip "undef" and nil values.
-      hash[param.name] = param.value if param.value != :undef && !param.value.nil?
-      hash
+    @parameters.reduce({}) do |result, (_, param)|
+      value = param.value
+      value = (value == :undef) ? nil : value
+
+      unless value.nil?
+        case param.name
+        when :before, :subscribe, :notify, :require
+          value = value.flatten if value.is_a?(Array)
+          result[param.name] = value
+        else
+          result[param.name] = value
+        end
+      end
+      result
     end
   end
 

data/lib/puppet/parser/scope.rb

@@ -504,29 +504,32 @@ class Puppet::Parser::Scope
   end
 
   UNDEFINED_VARIABLES_KIND = 'undefined_variables'.freeze
+  DEPRECATION_KIND = 'deprecation'.freeze
+
+  # The exception raised when a throw is uncaught is different in different versions
+  # of ruby. In >=2.2.0 it is UncaughtThrowError (which did not exist prior to this)
+  #
+  UNCAUGHT_THROW_EXCEPTION = defined?(UncaughtThrowError) ? UncaughtThrowError : ArgumentError
 
   def variable_not_found(name, reason=nil)
-    # Built in variables always exist
-    if BUILT_IN_VARS.include?(name)
+    # Built in variables and numeric variables always exist
+    if BUILT_IN_VARS.include?(name) || name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
       return nil
     end
-    if Puppet[:strict_variables]
+    begin
       throw(:undefined_variable, reason)
-    else
-      # Always warn, unfortunately without location (unless given in "reason") since
-      # a location is in most cases not given to scope (operator [], and lookupvar), and
-      # would be too expensive to always give.
-      # The ideal solution would be to always throw :undefined_variable, but that has to
-      # wait until a major release. It would then force all callers of scope to deal with
-      # the case of :undefined_variable. (Should check with include? first or catch the throw).
-      # Use deprecation warning to enable turning off these warnings, and to ensure each variable
-      # is only logged once.
-      unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
+    rescue  UNCAUGHT_THROW_EXCEPTION
+      case Puppet[:strict]
+      when :off
+        # do nothing
+      when :warning
         Puppet.warn_once(UNDEFINED_VARIABLES_KIND, "Variable: #{name}",
-          "Undefined variable '#{name}'; #{reason}" )
+        "Undefined variable '#{name}'; #{reason}" )
+      when :error
+        raise ArgumentError, "Undefined variable '#{name}'; #{reason}"
       end
-      nil
     end
+    nil
   end
 
   # Retrieves the variable value assigned to the name given as an argument. The name must be a String,

data/lib/puppet/plugins/data_providers/data_provider.rb

@@ -1,5 +1,9 @@
+require 'puppet/pops/lookup/interpolation'
+
 module Puppet::Plugins::DataProviders
   module DataProvider
+    include Puppet::Pops::Lookup::Interpolation
+
     # Performs a lookup with an endless recursion check.
     #
     # @param key [String] The key to lookup
@@ -19,10 +23,13 @@ module Puppet::Plugins::DataProviders
     #
     # @api public
     def unchecked_lookup(key, lookup_invocation, merge)
+      segments = split_key(key)
+      root_key = segments.shift
       lookup_invocation.with(:data_provider, self) do
-        hash = data(data_key(key, lookup_invocation), lookup_invocation)
-        value = hash[key]
-        if value || hash.include?(key)
+        hash = data(data_key(root_key, lookup_invocation), lookup_invocation)
+        value = hash[root_key]
+        if value || hash.include?(root_key)
+          value = sub_lookup(key, lookup_invocation, segments, value) unless segments.empty?
           lookup_invocation.report_found(key, post_process(value, lookup_invocation))
         else
           lookup_invocation.report_not_found(key)
@@ -31,8 +38,8 @@ module Puppet::Plugins::DataProviders
       end
     end
 
-    # Perform optional post processing of found value. This hook is used by the hiera style
-    # providers to perform interpolation. The default method simply returns the given _value_.
+    # Perform optional post processing of found value. The default implementation resolves
+    # interpolation expressions
     #
     # @param value [Object] The value to perform post processing on
     # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
@@ -40,7 +47,7 @@ module Puppet::Plugins::DataProviders
     #
     # @api public
     def post_process(value, lookup_invocation)
-      value
+      interpolate(value, lookup_invocation, true)
     end
 
     # Gets the data from the compiler, or initializes it by calling #initialize_data if not present in the compiler.
@@ -223,6 +230,9 @@ module Puppet::Plugins::DataProviders
     #
     # @api public
     def unchecked_lookup(key, lookup_invocation, merge)
+      segments = split_key(key)
+      root_key = segments.shift
+
       module_name = @parent_data_provider.nil? ? nil : @parent_data_provider.data_key(key, lookup_invocation)
       lookup_invocation.with(:data_provider, self) do
         merge_strategy = Puppet::Pops::MergeStrategy.strategy(merge)
@@ -231,8 +241,9 @@ module Puppet::Plugins::DataProviders
             lookup_invocation.with(:path, path) do
               if path.exists?
                 hash = load_data(path.path, module_name, lookup_invocation)
-                value = hash[key]
-                if value || hash.include?(key)
+                value = hash[root_key]
+                if value || hash.include?(root_key)
+                  value = sub_lookup(key, lookup_invocation, segments, value) unless segments.empty?
                   lookup_invocation.report_found(key, post_process(value, lookup_invocation))
                 else
                   lookup_invocation.report_not_found(key)

data/lib/puppet/pops.rb

@@ -10,6 +10,8 @@ module Puppet
   #
   # @api public
   module Pops
+    require 'semantic'
+
     require 'puppet/pops/patterns'
     require 'puppet/pops/utils'
 
@@ -27,13 +29,16 @@ module Puppet
     require 'puppet/pops/validation'
     require 'puppet/pops/issue_reporter'
     require 'puppet/pops/lookup'
+    require 'puppet/pops/lookup/interpolation'
     require 'puppet/pops/lookup/invocation'
+    require 'puppet/pops/lookup/sub_lookup'
     require 'puppet/pops/lookup/explainer'
 
     require 'puppet/pops/model/model'
 
     # (the Types module initializes itself)
     require 'puppet/pops/types/types'
+    require 'puppet/pops/types/string_converter'
 
     require 'puppet/pops/merge_strategy'
 
@@ -77,6 +82,7 @@ module Puppet
     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_support'

data/lib/puppet/pops/adapters.rb

@@ -103,7 +103,11 @@ module Adapters
     # Produces an URI with path?line=n&pos=n. If origin is unknown the URI is string:?line=n&pos=n
     def to_uri
       f = locator.file
-      f = 'string:' if f.nil? || f.empty?
+      if f.nil? || f.empty?
+        f = 'string:'
+      else
+        f = Puppet::Util.path_to_uri(f).to_s
+      end
       URI("#{f}?line=#{line.to_s}&pos=#{pos.to_s}")
     end
   end

data/lib/puppet/pops/evaluator/access_operator.rb

@@ -154,6 +154,12 @@ class AccessOperator
     Types::TypeFactory.variant(*keys)
   end
 
+  def access_PSemVerType(o, scope, keys)
+    keys.flatten!
+    assert_keys(keys, o, 1, Float::INFINITY, String, Semantic::VersionRange)
+    Types::TypeFactory.sem_ver(*keys)
+  end
+
   def access_PTupleType(o, scope, keys)
     keys.flatten!
     if Types::TypeFactory.is_range_parameter?(keys[-2]) && Types::TypeFactory.is_range_parameter?(keys[-1])
@@ -260,6 +266,15 @@ class AccessOperator
     end
   end
 
+  def access_PObjectType(o, scope, keys)
+    keys.flatten!
+    if keys.size == 1
+      Types::TypeFactory.object(keys[0])
+    else
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Object-Type', :min => 1, :actual => keys.size})
+    end
+  end
+
   def access_PNotUndefType(o, scope, keys)
     keys.flatten!
     case keys.size
@@ -357,6 +372,10 @@ class AccessOperator
   #
   def access_PHashType(o, scope, keys)
     keys.flatten!
+    if keys.size == 2 && keys[0].is_a?(Integer) && keys[1].is_a?(Integer)
+      return Types::PHashType.new(nil, nil, Types::PIntegerType.new(*keys))
+    end
+
     keys[0,2].each_with_index do |k, index|
       unless k.is_a?(Types::PAnyType)
         fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[index], {:base_type => 'Hash-Type', :actual => k.class})
@@ -364,18 +383,18 @@ class AccessOperator
     end
     case keys.size
     when 2
-      Types::PHashType.new(keys[0], keys[1], nil)
+      size_t = nil
     when 3
       size_t = keys[2]
       size_t = Types::PIntegerType.new(size_t) unless size_t.is_a?(Types::PIntegerType)
-      Types::PHashType.new(keys[0], keys[1], size_t)
     when 4
-      Types::PHashType.new(keys[0], keys[1], collection_size_t(1, keys[2], keys[3]))
+      size_t = collection_size_t(2, keys[2], keys[3])
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {
         :base_type => 'Hash-Type', :min => 2, :max => 4, :actual => keys.size
       })
     end
+    Types::PHashType.new(keys[0], keys[1], size_t)
   end
 
   # CollectionType is parameterized with a range
@@ -383,9 +402,9 @@ class AccessOperator
     keys.flatten!
     case keys.size
     when 1
-      size_t = collection_size_t(1, keys[0])
+      size_t = collection_size_t(0, keys[0])
     when 2
-      size_t = collection_size_t(1, keys[0], keys[1])
+      size_t = collection_size_t(0, keys[0], keys[1])
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic,
         {:base_type => 'Collection-Type', :min => 1, :max => 2, :actual => keys.size})
@@ -399,19 +418,31 @@ class AccessOperator
     keys.flatten!
     case keys.size
     when 1
+      unless keys[0].is_a?(Types::PAnyType)
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
+      end
+      type = keys[0]
       size_t = nil
     when 2
-      size_t = collection_size_t(1, keys[1])
+      if keys[0].is_a?(Types::PAnyType)
+        size_t = collection_size_t(1, keys[1])
+        type = keys[0]
+      else
+        size_t = collection_size_t(0, keys[0], keys[1])
+        type = nil
+      end
     when 3
-      size_t = collection_size_t(1, keys[1], keys[2])
+      if keys[0].is_a?(Types::PAnyType)
+        size_t = collection_size_t(1, keys[1], keys[2])
+        type = keys[0]
+      else
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
+      end
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic,
         {:base_type => 'Array-Type', :min => 1, :max => 3, :actual => keys.size})
     end
-    unless keys[0].is_a?(Types::PAnyType)
-      fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
-    end
-    Types::PArrayType.new(keys[0], size_t)
+    Types::PArrayType.new(type, size_t)
   end
 
   # Produces an PIntegerType (range) given one or two keys.
@@ -438,6 +469,11 @@ class AccessOperator
     access(t, scope, *keys)
   end
 
+  # If a type reference is encountered here, it's an error
+  def access_PTypeReferenceType(o, scope, keys)
+    fail(Issues::UNKNOWN_RESOURCE_TYPE, @semantic, {:type_name => o.type_string })
+  end
+
   # A Resource can create a new more specific Resource type, and/or an array of resource types
   # If the given type has title set, it can not be specified further.
   # @example
@@ -461,12 +497,12 @@ class AccessOperator
     # Must know which concrete resource type to operate on in all cases.
     # It is not allowed to specify the type in an array arg - e.g. Resource[[File, 'foo']]
     # type_name is LHS type_name if set, else the first given arg
-    type_name = o.type_name || keys.shift
+    type_name = o.type_name || Types::TypeFormatter.singleton.capitalize_segments(keys.shift)
     type_name = case type_name
     when Types::PResourceType
       type_name.type_name
     when String
-      type_name.downcase
+      type_name
     else
       # blame given left expression if it defined the type, else the first given key expression
       blame = o.type_name.nil? ? @semantic.keys[0] : @semantic.left_expr
@@ -474,7 +510,7 @@ class AccessOperator
     end
 
     # type name must conform
-    if type_name !~ Patterns::CLASSREF
+    if type_name !~ Patterns::CLASSREF_EXT
       fail(Issues::ILLEGAL_CLASSREF, blamed, {:name=>type_name})
     end
 
@@ -565,6 +601,8 @@ class AccessOperator
                  c.type_name
                elsif c.is_a?(String)
                  c.downcase
+               elsif c.is_a?(Types::PTypeReferenceType)
+                 c.type_string.downcase
                else
                  fail(Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
                end

data/lib/puppet/pops/evaluator/compare_operator.rb

@@ -21,7 +21,6 @@ class CompareOperator
     @@compare_visitor ||= Visitor.new(self, "cmp", 1, 1)
     @@match_visitor ||= Visitor.new(self, "match", 2, 2)
     @@include_visitor ||= Visitor.new(self, "include", 2, 2)
-    @type_calculator = Types::TypeCalculator.new()
   end
 
   def equals (a, b)
@@ -93,8 +92,13 @@ class CompareOperator
     end
   end
 
+  def cmp_Version(a, b)
+    raise ArgumentError.new('Versions not comparable to non Versions') unless b.is_a?(Semantic::Version)
+    a <=> b
+  end
+
   def cmp_Object(a, b)
-    raise ArgumentError.new("Only Strings and Numbers are comparable")
+    raise ArgumentError.new('Only Strings, Numbers, and Versions are comparable')
   end
 
 
@@ -145,8 +149,10 @@ class CompareOperator
       # Always set match data, a "not found" should not keep old match data visible
       set_match_data(matched, scope) # creates ephemeral
       return !!matched
+    when String, Semantic::Version
+      a.any? { |element| match(b, element, scope) }
     when Types::PAnyType
-      a.each {|element| return true if @type_calculator.instance?(b, element) }
+      a.each {|element| return true if b.instance?(element) }
       return false
     else
       a.each {|element| return true if equals(element, b) }
@@ -158,6 +164,10 @@ class CompareOperator
     include?(a.keys, b, scope)
   end
 
+  def include_VersionRange(a, b, scope)
+    Types::PSemVerRangeType.include?(a, b)
+  end
+
   # Matches in general by using == operator
   def match_Object(pattern, a, scope)
     equals(a, pattern)
@@ -171,12 +181,32 @@ class CompareOperator
     !!matched # convert to boolean
   end
 
+  # Matches against semvers and strings
+  def match_Version(version, left, scope)
+    if left.is_a?(Semantic::Version)
+      version == left
+    elsif left.is_a? String
+      begin
+        version == Semantic::Version.parse(left)
+      rescue ArgumentError
+        false
+      end
+    else
+      false
+    end
+  end
+
+  # Matches against semvers and strings
+  def match_VersionRange(range, left, scope)
+    Types::PSemVerRangeType.include?(range, left)
+  end
+
   def match_PAnyType(any_type, left, scope)
     # right is a type and left is not - check if left is an instance of the given type
     # (The reverse is not terribly meaningful - computing which of the case options that first produces
     # an instance of a given type).
     #
-    @type_calculator.instance?(any_type, left)
+    any_type.instance?(left)
   end
 
   def match_Array(array, left, scope)

data/lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -77,7 +77,7 @@ class EvaluatorImpl
       @@eval_visitor.visit_this_1(self, target, scope)
 
     rescue SemanticError => e
-      # A raised issue may not know the semantic target, use errors call stack, but fill in the 
+      # A raised issue may not know the semantic target, use errors call stack, but fill in the
       # rest from a supplied semantic object, or the target instruction if there is not semantic
       # object.
       #
@@ -223,6 +223,28 @@ class EvaluatorImpl
           values.fetch(lval) {|k| fail(Issues::MISSING_MULTI_ASSIGNMENT_KEY, o, :key =>k)},
           o, scope)
       end
+    elsif values.is_a?(Puppet::Pops::Types::PHostClassType)
+      # assign variables from class variables
+      # lookup class resource and return one or more parameter values
+      # TODO: behavior when class_name is nil
+      resource = find_resource(scope, 'class', values.class_name)
+      if resource
+        base_name = "#{values.class_name.downcase}::"
+        idx = -1
+        result = lvalues.map do |lval|
+          idx += 1
+          varname = "#{base_name}#{lval}"
+          if variable_exists?(varname, scope)
+            result = get_variable_value(varname, o, scope)
+            assign(lval, result, o, scope)
+          else
+            fail(Puppet::Pops::Issues::MISSING_MULTI_ASSIGNMENT_VARIABLE, o.left_expr.values[idx], {:name => varname})
+          end
+        end
+      else
+        fail(Issues::UNKNOWN_RESOURCE, o.right_expr, {:type_name => 'Class', :title => values.class_name})
+      end
+
     else
       values = [values] unless values.is_a?(Array)
       if values.size != lvalues.size
@@ -278,7 +300,9 @@ class EvaluatorImpl
   # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
   #
   def eval_QualifiedReference(o, scope)
-    @@type_parser.interpret(o, scope)
+    type = @@type_parser.interpret(o, scope)
+    fail(Issues::UNKNOWN_RESOURCE_TYPE, o, {:type_name => type.type_string }) if type.is_a?(Types::PTypeReferenceType)
+    type
   end
 
   def eval_NotExpression(o, scope)
@@ -424,7 +448,15 @@ class EvaluatorImpl
   #
   def eval_AccessExpression(o, scope)
     left = evaluate(o.left_expr, scope)
-    keys = o.keys.nil? ? [] : o.keys.collect {|key| evaluate(key, scope) }
+    keys = o.keys || []
+    if left.is_a?(Types::PHostClassType)
+      # Evaluate qualified references without errors no undefined types
+      keys = keys.map {|key| key.is_a?(Model::QualifiedReference) ? @@type_parser.interpret(key, scope) : evaluate(key, scope) }
+    else
+      keys = keys.map {|key| evaluate(key, scope) }
+      # Resource[File] becomes File
+      return keys[0] if Types::PResourceType::DEFAULT == left && keys.size == 1 && keys[0].is_a?(Types::PResourceType)
+    end
     AccessOperator.new(o).access(left, scope, *keys)
   end
 
@@ -511,11 +543,17 @@ class EvaluatorImpl
     # matches RHS types as instance of for all types except a parameterized Regexp[R]
     if pattern.is_a?(Types::PAnyType)
       # evaluate as instance? of type check
-      matched = @@type_calculator.instance?(pattern, left)
+      matched = pattern.instance?(left)
       # convert match result to Boolean true, or false
       return o.operator == :'=~' ? !!matched : !matched
     end
 
+    if pattern.is_a?(Semantic::VersionRange)
+      # evaluate if range includes version
+      matched = Types::PSemVerRangeType.include?(pattern, left)
+      return o.operator == :'=~' ? matched : !matched
+    end
+
     begin
       pattern = Regexp.new(pattern) unless pattern.is_a?(Regexp)
     rescue StandardError => e
@@ -692,6 +730,9 @@ class EvaluatorImpl
         end
         evaluated_name.type_name # assume validated
 
+      when Types::PTypeReferenceType
+        fail(Issues::UNKNOWN_RESOURCE_TYPE, o.type_string, {:type_name => evaluated_name.to_s})
+
       else
         actual = type_calculator.generalize(type_calculator.infer(evaluated_name)).to_s
         fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=>actual})
@@ -814,9 +855,20 @@ class EvaluatorImpl
   # Evaluates function call by name.
   #
   def eval_CallNamedFunctionExpression(o, scope)
+    # If LHS is a type (i.e. Integer, or Integer[...]
+    # the call is taken as an instantiation of the given type
+    #
+    functor = o.functor_expr
+    if functor.is_a?(Model::QualifiedReference) ||
+      functor.is_a?(Model::AccessExpression) && functor.left_expr.is_a?(Model::QualifiedReference)
+      # instantiation
+      type = evaluate(functor, scope)
+      return call_function_with_block('new', unfold([type], o.arguments || [], scope), o, scope)
+    end
+
     # The functor expression is not evaluated, it is not possible to select the function to call
     # via an expression like $a()
-    case o.functor_expr
+    case functor
     when Model::QualifiedName
       # ok
     when Model::RenderStringExpression
@@ -841,6 +893,17 @@ class EvaluatorImpl
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
     name = name.value # the string function name
+
+    obj = receiver[0]
+    receiver_type = Types::TypeCalculator.infer(obj)
+    if receiver_type.is_a?(Types::PObjectType)
+      member = receiver_type[name]
+      unless member.nil?
+        args = unfold([], o.arguments || [], scope)
+        return o.lambda.nil? ? member.invoke(obj, scope, args) : member.invoke(obj, scope, args, &proc_from_lambda(o.lambda, scope))
+      end
+    end
+
     call_function_with_block(name, unfold(receiver, o.arguments || [], scope), o, scope)
   end
 
@@ -848,12 +911,17 @@ class EvaluatorImpl
     if o.lambda.nil?
       call_function(name, evaluated_arguments, o, scope)
     else
-      closure = Closure.new(self, o.lambda, scope)
-      call_function(name, evaluated_arguments, o, scope, &PuppetProc.new(closure) { |*args| closure.call(*args) })
+      call_function(name, evaluated_arguments, o, scope, &proc_from_lambda(o.lambda, scope))
     end
   end
   private :call_function_with_block
 
+  def proc_from_lambda(lambda, scope)
+    closure = Closure.new(self, lambda, scope)
+    PuppetProc.new(closure) { |*args| closure.call(*args) }
+  end
+  private :proc_from_lambda
+
   # @example
   #   $x ? { 10 => true, 20 => false, default => 0 }
   #
@@ -1117,21 +1185,6 @@ class EvaluatorImpl
   # of value except regular expression where a match is performed.
   #
   def is_match?(left, right, o, option_expr, scope)
-    if right.is_a?(Regexp)
-      return false unless left.is_a? String
-      matched = right.match(left)
-      set_match_data(matched, scope) # creates or clears ephemeral
-      !!matched # convert to boolean
-    elsif right.is_a?(Types::PAnyType)
-      # right is a type and left is not - check if left is an instance of the given type
-      # (The reverse is not terribly meaningful - computing which of the case options that first produces
-      # an instance of a given type).
-      #
-      @@type_calculator.instance?(right, left)
-    else
-      # Handle equality the same way as the language '==' operator (case insensitive etc.)
-      @@compare_operator.equals(left,right)
-    end
     @@compare_operator.match(left, right, scope)
   end