puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/parser/ast/collexpr.rb

@@ -0,0 +1,57 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+require 'puppet/parser/collector'
+
+# An object that collects stored objects from the central cache and returns
+# them to the current host, yo.
+class Puppet::Parser::AST
+class CollExpr < AST::Branch
+  attr_accessor :test1, :test2, :oper, :form, :type, :parens
+
+  # We return an object that does a late-binding evaluation.
+  def evaluate(scope)
+    # Make sure our contained expressions have all the info they need.
+    [@test1, @test2].each do |t|
+      if t.is_a?(self.class)
+        t.form ||= self.form
+        t.type ||= self.type
+      end
+    end
+
+    # The code is only used for virtual lookups
+    match1, code1 = @test1.safeevaluate scope
+    match2, code2 = @test2.safeevaluate scope
+
+    # First build up the virtual code.
+    # If we're a conjunction operator, then we're calling code.  I did
+    # some speed comparisons, and it's at least twice as fast doing these
+    # case statements as doing an eval here.
+    code = proc do |resource|
+      case @oper
+      when "and"; code1.call(resource) and code2.call(resource)
+      when "or"; code1.call(resource) or code2.call(resource)
+      when "=="
+        if match1 == "tag"
+          resource.tagged?(match2)
+        else
+          if resource[match1].is_a?(Array)
+            resource[match1].include?(match2)
+          else
+            resource[match1] == match2
+          end
+        end
+      when "!="; resource[match1] != match2
+      end
+    end
+
+    match = [match1, @oper, match2]
+    return match, code
+  end
+
+  def initialize(hash = {})
+    super
+
+    raise ArgumentError, "Invalid operator #{@oper}" unless %w{== != and or}.include?(@oper)
+  end
+end
+end

data/lib/vendor/puppet/parser/ast/comparison_operator.rb

@@ -0,0 +1,38 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  class ComparisonOperator < AST::Branch
+
+    attr_accessor :operator, :lval, :rval
+
+    # Iterate across all of our children.
+    def each
+      [@lval,@rval,@operator].each { |child| yield child }
+    end
+
+    # Returns a boolean which is the result of the boolean operation
+    # of lval and rval operands
+    def evaluate(scope)
+      # evaluate the operands, should return a boolean value
+      lval = @lval.safeevaluate(scope)
+
+      case @operator
+      when "==","!="
+        @rval.evaluate_match(lval, scope) ? @operator == '==' : @operator == '!='
+      else
+        rval = @rval.safeevaluate(scope)
+        rval = Puppet::Parser::Scope.number?(rval) || rval
+        lval = Puppet::Parser::Scope.number?(lval) || lval
+
+        lval.send(@operator,rval)
+      end
+    end
+
+    def initialize(hash)
+      super
+
+      raise ArgumentError, "Invalid comparison operator #{@operator}" unless %w{== != < > <= >=}.include?(@operator)
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/definition.rb

@@ -0,0 +1,17 @@
+require 'puppet/parser/ast/top_level_construct'
+
+class Puppet::Parser::AST::Definition < Puppet::Parser::AST::TopLevelConstruct
+  attr_accessor :context
+
+  def initialize(name, context = {}, &ruby_code)
+    @name = name
+    @context = context
+    @ruby_code = ruby_code
+  end
+
+  def instantiate(modname)
+    new_definition = Puppet::Resource::Type.new(:definition, @name, @context.merge(:module_name => modname))
+    new_definition.ruby_code = @ruby_code if @ruby_code
+    [new_definition]
+  end
+end

data/lib/vendor/puppet/parser/ast/else.rb

@@ -0,0 +1,22 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  # A separate ElseIf statement; can function as an 'else' if there's no
+  # test.
+  class Else < AST::Branch
+
+    associates_doc
+
+    attr_accessor :statements
+
+    def each
+      yield @statements
+    end
+
+    # Evaluate the actual statements; this only gets called if
+    # our test was true matched.
+    def evaluate(scope)
+      @statements.safeevaluate(scope)
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/function.rb

@@ -0,0 +1,50 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  # An AST object to call a function.
+  class Function < AST::Branch
+
+    associates_doc
+
+    attr_accessor :name, :arguments
+
+    @settor = true
+
+    def evaluate(scope)
+      # Make sure it's a defined function
+      raise Puppet::ParseError, "Unknown function #{@name}" unless Puppet::Parser::Functions.function(@name)
+
+      # Now check that it's been used correctly
+      case @ftype
+      when :rvalue
+        raise Puppet::ParseError, "Function '#{@name}' does not return a value" unless Puppet::Parser::Functions.rvalue?(@name)
+      when :statement
+        if Puppet::Parser::Functions.rvalue?(@name)
+          raise Puppet::ParseError,
+            "Function '#{@name}' must be the value of a statement"
+        end
+      else
+        raise Puppet::DevError, "Invalid function type #{@ftype.inspect}"
+      end
+
+      # We don't need to evaluate the name, because it's plaintext
+      args = @arguments.safeevaluate(scope).map { |x| x == :undef ? '' : x }
+
+      scope.send("function_#{@name}", args)
+    end
+
+    def initialize(hash)
+      @ftype = hash[:ftype] || :rvalue
+      hash.delete(:ftype) if hash.include? :ftype
+
+      super(hash)
+
+      # Lastly, check the parity
+    end
+
+    def to_s
+      args = arguments.is_a?(ASTArray) ? arguments.to_s.gsub(/\[(.*)\]/,'\1') : arguments
+      "#{name}(#{args})"
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/hostclass.rb

@@ -0,0 +1,29 @@
+require 'puppet/parser/ast/top_level_construct'
+
+class Puppet::Parser::AST::Hostclass < Puppet::Parser::AST::TopLevelConstruct
+  attr_accessor :name, :context
+
+  def initialize(name, context = {}, &ruby_code)
+    @context = context
+    @name = name
+    @ruby_code = ruby_code
+  end
+
+  def instantiate(modname)
+    new_class = Puppet::Resource::Type.new(:hostclass, @name, @context.merge(:module_name => modname))
+    new_class.ruby_code = @ruby_code if @ruby_code
+    all_types = [new_class]
+    if code
+      code.each do |nested_ast_node|
+        if nested_ast_node.respond_to? :instantiate
+          all_types += nested_ast_node.instantiate(modname)
+        end
+      end
+    end
+    return all_types
+  end
+
+  def code()
+    @context[:code]
+  end
+end

data/lib/vendor/puppet/parser/ast/ifstatement.rb

@@ -0,0 +1,34 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  # A basic 'if/elsif/else' statement.
+  class IfStatement < AST::Branch
+
+    associates_doc
+
+    attr_accessor :test, :else, :statements
+
+    def each
+      [@test,@else,@statements].each { |child| yield child }
+    end
+
+    # Short-curcuit evaluation.  If we're true, evaluate our statements,
+    # else if there's an 'else' setting, evaluate it.
+    # the first option that matches.
+    def evaluate(scope)
+      level = scope.ephemeral_level
+      value = @test.safeevaluate(scope)
+
+      # let's emulate a new scope for each branches
+      begin
+        if Puppet::Parser::Scope.true?(value)
+          return @statements.safeevaluate(scope)
+        else
+          return defined?(@else) ? @else.safeevaluate(scope) : nil
+        end
+      ensure
+        scope.unset_ephemeral_var(level)
+      end
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/in_operator.rb

@@ -0,0 +1,24 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  class InOperator < AST::Branch
+
+    attr_accessor :lval, :rval
+
+    # Returns a boolean which is the result of the 'in' operation
+    # of lval and rval operands
+    def evaluate(scope)
+
+      # evaluate the operands, should return a boolean value
+      lval = @lval.safeevaluate(scope)
+      raise ArgumentError, "'#{lval}' from left operand of 'in' expression is not a string" unless lval.is_a?(::String)
+
+      rval = @rval.safeevaluate(scope)
+      unless rval.respond_to?(:include?)
+        raise ArgumentError, "'#{rval}' from right operand of 'in' expression is not of a supported type (string, array or hash)"
+      end
+      rval.include?(lval)
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/leaf.rb

@@ -0,0 +1,221 @@
+class Puppet::Parser::AST
+  # The base class for all of the leaves of the parse trees.  These
+  # basically just have types and values.  Both of these parameters
+  # are simple values, not AST objects.
+  class Leaf < AST
+    attr_accessor :value, :type
+
+    # Return our value.
+    def evaluate(scope)
+      @value
+    end
+
+    def match(value)
+      @value == value
+    end
+
+    def to_s
+      @value.to_s unless @value.nil?
+    end
+  end
+
+  # The boolean class.  True or false.  Converts the string it receives
+  # to a Ruby boolean.
+  class Boolean < AST::Leaf
+
+    # Use the parent method, but then convert to a real boolean.
+    def initialize(hash)
+      super
+
+      unless @value == true or @value == false
+        raise Puppet::DevError,
+          "'#{@value}' is not a boolean"
+      end
+      @value
+    end
+
+    def to_s
+      @value ? "true" : "false"
+    end
+  end
+
+  # The base string class.
+  class String < AST::Leaf
+    def evaluate(scope)
+      @value.dup
+    end
+
+    def to_s
+      "\"#{@value}\""
+    end
+  end
+
+  # An uninterpreted string.
+  class FlatString < AST::Leaf
+    def evaluate(scope)
+      @value
+    end
+
+    def to_s
+      "\"#{@value}\""
+    end
+  end
+
+  class Concat < AST::Leaf
+    def evaluate(scope)
+      @value.collect { |x| x.evaluate(scope) }.collect{ |x| x == :undef ? '' : x }.join
+    end
+
+    def to_s
+      "#{@value.map { |s| s.to_s.gsub(/^"(.*)"$/, '\1') }.join}"
+    end
+  end
+
+  # The 'default' option on case statements and selectors.
+  class Default < AST::Leaf; end
+
+  # Capitalized words; used mostly for type-defaults, but also
+  # get returned by the lexer any other time an unquoted capitalized
+  # word is found.
+  class Type < AST::Leaf; end
+
+  # Lower-case words.
+  class Name < AST::Leaf; end
+
+  # double-colon separated class names
+  class ClassName < AST::Leaf; end
+
+  # undef values; equiv to nil
+  class Undef < AST::Leaf; end
+
+  # Host names, either fully qualified or just the short name, or even a regex
+  class HostName < AST::Leaf
+    def initialize(hash)
+      super
+
+      # Note that this is an AST::Regex, not a Regexp
+      @value = @value.to_s.downcase unless @value.is_a?(Regex)
+      if @value =~ /[^-\w.]/
+        raise Puppet::DevError,
+          "'#{@value}' is not a valid hostname"
+      end
+    end
+
+    # implementing eql? and hash so that when an HostName is stored
+    # in a hash it has the same hashing properties as the underlying value
+    def eql?(value)
+      value = value.value if value.is_a?(HostName)
+      @value.eql?(value)
+    end
+
+    def hash
+      @value.hash
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+
+  # A simple variable.  This object is only used during interpolation;
+  # the VarDef class is used for assignment.
+  class Variable < Name
+    # Looks up the value of the object in the scope tree (does
+    # not include syntactical constructs, like '$' and '{}').
+    def evaluate(scope)
+      parsewrap do
+        if (var = scope.lookupvar(@value, :file => file, :line => line)) == :undefined
+          var = :undef
+        end
+        var
+      end
+    end
+
+    def to_s
+      "\$#{value}"
+    end
+  end
+
+  class HashOrArrayAccess < AST::Leaf
+    attr_accessor :variable, :key
+
+    def evaluate_container(scope)
+      container = variable.respond_to?(:evaluate) ? variable.safeevaluate(scope) : variable
+      (container.is_a?(Hash) or container.is_a?(Array)) ? container : scope.lookupvar(container, :file => file, :line => line)
+    end
+
+    def evaluate_key(scope)
+      key.respond_to?(:evaluate) ? key.safeevaluate(scope) : key
+    end
+
+    def array_index_or_key(object, key)
+      if object.is_a?(Array)
+        raise Puppet::ParserError, "#{key} is not an integer, but is used as an index of an array" unless key = Puppet::Parser::Scope.number?(key)
+      end
+      key
+    end
+
+    def evaluate(scope)
+      object = evaluate_container(scope)
+      accesskey = evaluate_key(scope)
+
+      raise Puppet::ParseError, "#{variable} is not an hash or array when accessing it with #{accesskey}" unless object.is_a?(Hash) or object.is_a?(Array)
+
+      object[array_index_or_key(object, accesskey)] || :undef
+    end
+
+    # Assign value to this hashkey or array index
+    def assign(scope, value)
+      object = evaluate_container(scope)
+      accesskey = evaluate_key(scope)
+
+      if object.is_a?(Hash) and object.include?(accesskey)
+        raise Puppet::ParseError, "Assigning to the hash '#{variable}' with an existing key '#{accesskey}' is forbidden"
+      end
+
+      # assign to hash or array
+      object[array_index_or_key(object, accesskey)] = value
+    end
+
+    def to_s
+      "\$#{variable.to_s}[#{key.to_s}]"
+    end
+  end
+
+  class Regex < AST::Leaf
+    def initialize(hash)
+      super
+      @value = Regexp.new(@value) unless @value.is_a?(Regexp)
+    end
+
+    # we're returning self here to wrap the regexp and to be used in places
+    # where a string would have been used, without modifying any client code.
+    # For instance, in many places we have the following code snippet:
+    #  val = @val.safeevaluate(@scope)
+    #  if val.match(otherval)
+    #      ...
+    #  end
+    # this way, we don't have to modify this test specifically for handling
+    # regexes.
+    def evaluate(scope)
+      self
+    end
+
+    def evaluate_match(value, scope, options = {})
+      value = value == :undef ? '' : value.to_s
+
+      if matched = @value.match(value)
+        scope.ephemeral_from(matched, options[:file], options[:line])
+      end
+      matched
+    end
+
+    def match(value)
+      @value.match(value)
+    end
+
+    def to_s
+      "/#{@value.source}/"
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/match_operator.rb

@@ -0,0 +1,28 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  class MatchOperator < AST::Branch
+
+    attr_accessor :lval, :rval, :operator
+
+    # Iterate across all of our children.
+    def each
+      [@lval,@rval].each { |child| yield child }
+    end
+
+    # Returns a boolean which is the result of the boolean operation
+    # of lval and rval operands
+    def evaluate(scope)
+      lval = @lval.safeevaluate(scope)
+
+      return(rval.evaluate_match(lval, scope) ? @operator == "=~" : @operator == "!~")
+    end
+
+    def initialize(hash)
+      super
+
+      raise ArgumentError, "Invalid regexp operator #{@operator}" unless %w{!~ =~}.include?(@operator)
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/minus.rb

@@ -0,0 +1,23 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+# An object that returns a boolean which is the boolean not
+# of the given value.
+class Puppet::Parser::AST
+  class Minus < AST::Branch
+    attr_accessor :value
+
+    def each
+      yield @value
+    end
+
+    def evaluate(scope)
+      val = @value.safeevaluate(scope)
+      val = Puppet::Parser::Scope.number?(val)
+      if val == nil
+        raise ArgumentError, "minus operand #{val} is not a number"
+      end
+      -val
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/node.rb

@@ -0,0 +1,20 @@
+require 'puppet/parser/ast/top_level_construct'
+
+class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct
+  attr_accessor :names, :context
+
+  def initialize(names, context = {}, &ruby_code)
+    raise ArgumentError, "names should be an array" unless names.is_a? Array
+    @names = names
+    @context = context
+    @ruby_code = ruby_code
+  end
+
+  def instantiate(modname)
+    @names.collect do |name|
+      new_node = Puppet::Resource::Type.new(:node, name, @context.merge(:module_name => modname))
+      new_node.ruby_code = @ruby_code if @ruby_code
+      new_node
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/nop.rb

@@ -0,0 +1,11 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  # This class is a no-op, it doesn't produce anything
+  # when evaluated, hence it's name :-)
+  class Nop < AST::Leaf
+    def evaluate(scope)
+      # nothing to do
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/not.rb

@@ -0,0 +1,19 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+# An object that returns a boolean which is the boolean not
+# of the given value.
+class Puppet::Parser::AST
+  class Not < AST::Branch
+    attr_accessor :value
+
+    def each
+      yield @value
+    end
+
+    def evaluate(scope)
+      val = @value.safeevaluate(scope)
+      ! Puppet::Parser::Scope.true?(val)
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/relationship.rb

@@ -0,0 +1,47 @@
+require 'puppet/parser/ast'
+require 'puppet/parser/ast/branch'
+require 'puppet/parser/relationship'
+
+class Puppet::Parser::AST::Relationship < Puppet::Parser::AST::Branch
+  RELATIONSHIP_TYPES = %w{-> <- ~> <~}
+
+  attr_accessor :left, :right, :arrow, :type
+
+  # Evaluate our object, but just return a simple array of the type
+  # and name.
+  def evaluate(scope)
+    real_left = left.safeevaluate(scope)
+    real_right = right.safeevaluate(scope)
+
+    source, target = sides2edge(real_left, real_right)
+    scope.compiler.add_relationship Puppet::Parser::Relationship.new(source, target, type)
+
+    real_right
+  end
+
+  def initialize(left, right, arrow, args = {})
+    super(args)
+    unless RELATIONSHIP_TYPES.include?(arrow)
+      raise ArgumentError, "Invalid relationship type #{arrow.inspect}; valid types are #{RELATIONSHIP_TYPES.collect { |r| r.to_s }.join(", ")}"
+    end
+    @left, @right, @arrow = left, right, arrow
+  end
+
+  def type
+    subscription? ? :subscription : :relationship
+  end
+
+  def sides2edge(left, right)
+    out_edge? ? [left, right] : [right, left]
+  end
+
+  private
+
+  def out_edge?
+    ["->", "~>"].include?(arrow)
+  end
+
+  def subscription?
+    ["~>", "<~"].include?(arrow)
+  end
+end