puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/parser/parser_support.rb

@@ -0,0 +1,211 @@
+# I pulled this into a separate file, because I got
+# tired of rebuilding the parser.rb file all the time.
+class Puppet::Parser::Parser
+  require 'puppet/parser/functions'
+  require 'puppet/parser/files'
+  require 'puppet/resource/type_collection'
+  require 'puppet/resource/type_collection_helper'
+  require 'puppet/resource/type'
+  require 'monitor'
+
+  AST = Puppet::Parser::AST
+
+  include Puppet::Resource::TypeCollectionHelper
+
+  attr_reader :version, :environment
+  attr_accessor :files
+
+  attr_accessor :lexer
+
+  # Add context to a message; useful for error messages and such.
+  def addcontext(message, obj = nil)
+    obj ||= @lexer
+
+    message += " on line #{obj.line}"
+    if file = obj.file
+      message += " in file #{file}"
+    end
+
+    message
+  end
+
+  # Create an AST array containing a single element
+  def aryfy(arg)
+    ast AST::ASTArray, :children => [arg]
+  end
+
+  # Create an AST object, and automatically add the file and line information if
+  # available.
+  def ast(klass, hash = {})
+    klass.new ast_context(klass.use_docs, hash[:line]).merge(hash)
+  end
+
+  def ast_context(include_docs = false, ast_line = nil)
+    result = {
+      :line => ast_line || lexer.line,
+      :file => lexer.file
+    }
+    result[:doc] = lexer.getcomment(result[:line]) if include_docs
+    result
+  end
+
+  # The fully qualifed name, with the full namespace.
+  def classname(name)
+    [@lexer.namespace, name].join("::").sub(/^::/, '')
+  end
+
+  def clear
+    initvars
+  end
+
+  # Raise a Parse error.
+  def error(message, options = {})
+    if brace = @lexer.expected
+      message += "; expected '%s'"
+    end
+    except = Puppet::ParseError.new(message)
+    except.line = options[:line] || @lexer.line
+    except.file = options[:file] || @lexer.file
+
+    raise except
+  end
+
+  def file
+    @lexer.file
+  end
+
+  def file=(file)
+    unless FileTest.exist?(file)
+      unless file =~ /\.pp$/
+        file = file + ".pp"
+      end
+    end
+    raise Puppet::AlreadyImportedError, "Import loop detected" if known_resource_types.watching_file?(file)
+
+    watch_file(file)
+    @lexer.file = file
+  end
+
+  [:hostclass, :definition, :node, :nodes?].each do |method|
+    define_method(method) do |*args|
+      known_resource_types.send(method, *args)
+    end
+  end
+
+  def find_hostclass(namespace, name)
+    known_resource_types.find_hostclass(namespace, name)
+  end
+
+  def find_definition(namespace, name)
+    known_resource_types.find_definition(namespace, name)
+  end
+
+  def import(file)
+    known_resource_types.loader.import(file, @lexer.file)
+  end
+
+  def initialize(env)
+    # The environment is needed to know how to find the resource type collection.
+    @environment = env.is_a?(String) ? Puppet::Node::Environment.new(env) : env
+    initvars
+  end
+
+  # Initialize or reset all of our variables.
+  def initvars
+    @lexer = Puppet::Parser::Lexer.new
+  end
+
+  # Split an fq name into a namespace and name
+  def namesplit(fullname)
+    ary = fullname.split("::")
+    n = ary.pop || ""
+    ns = ary.join("::")
+    return ns, n
+  end
+
+  def on_error(token,value,stack)
+    if token == 0 # denotes end of file
+      value = 'end of file'
+    else
+      value = "'#{value[:value]}'"
+    end
+    error = "Syntax error at #{value}"
+
+    if brace = @lexer.expected
+      error += "; expected '#{brace}'"
+    end
+
+    except = Puppet::ParseError.new(error)
+    except.line = @lexer.line
+    except.file = @lexer.file if @lexer.file
+
+    raise except
+  end
+
+  # how should I do error handling here?
+  def parse(string = nil)
+    if self.file =~ /\.rb$/
+      main = parse_ruby_file
+    else
+      self.string = string if string
+      begin
+        @yydebug = false
+        main = yyparse(@lexer,:scan)
+      rescue Racc::ParseError => except
+        error = Puppet::ParseError.new(except)
+        error.line = @lexer.line
+        error.file = @lexer.file
+        error.set_backtrace except.backtrace
+        raise error
+      rescue Puppet::ParseError => except
+        except.line ||= @lexer.line
+        except.file ||= @lexer.file
+        raise except
+      rescue Puppet::Error => except
+        # and this is a framework error
+        except.line ||= @lexer.line
+        except.file ||= @lexer.file
+        raise except
+      rescue Puppet::DevError => except
+        except.line ||= @lexer.line
+        except.file ||= @lexer.file
+        raise except
+      rescue => except
+        error = Puppet::DevError.new(except.message)
+        error.line = @lexer.line
+        error.file = @lexer.file
+        error.set_backtrace except.backtrace
+        raise error
+      end
+    end
+    # Store the results as the top-level class.
+    return Puppet::Parser::AST::Hostclass.new('', :code => main)
+  ensure
+    @lexer.clear
+  end
+
+  def parse_ruby_file
+    # Execute the contents of the file inside its own "main" object so
+    # that it can call methods in the resource type API.
+    main_object = Puppet::DSL::ResourceTypeAPI.new
+    main_object.instance_eval(File.read(self.file))
+
+    # Then extract any types that were created.
+    Puppet::Parser::AST::ASTArray.new :children => main_object.instance_eval { @__created_ast_objects__ }
+  end
+
+  def string=(string)
+    @lexer.string = string
+  end
+
+  def version
+    known_resource_types.version
+  end
+
+  # Add a new file to be checked when we're checking to see if we should be
+  # reparsed.  This is basically only used by the TemplateWrapper to let the
+  # parser know about templates that should be parsed.
+  def watch_file(filename)
+    known_resource_types.watch_file(filename)
+  end
+end

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

@@ -0,0 +1,62 @@
+class Puppet::Parser::Relationship
+  attr_accessor :source, :target, :type
+
+  PARAM_MAP = {:relationship => :before, :subscription => :notify}
+
+  def arrayify(resources)
+    case resources
+    when Puppet::Parser::Collector
+      resources.collected.values
+    when Array
+      resources
+    else
+      [resources]
+    end
+  end
+
+  def evaluate(catalog)
+    arrayify(source).each do |s|
+      arrayify(target).each do |t|
+        mk_relationship(s, t, catalog)
+      end
+    end
+  end
+
+  def initialize(source, target, type)
+    @source, @target, @type = source, target, type
+  end
+
+  def param_name
+    PARAM_MAP[type] || raise(ArgumentError, "Invalid relationship type #{type}")
+  end
+
+  def mk_relationship(source, target, catalog)
+    # REVISIT: In Ruby 1.8 we applied `to_s` to source and target, rather than
+    # `join` without an argument.  In 1.9 the behaviour of Array#to_s changed,
+    # and it gives a different representation than just concat the stringified
+    # elements.
+    #
+    # This restores the behaviour, but doesn't address the underlying question
+    # of what would happen when more than one item was passed in that array.
+    # (Hint: this will not end well.)
+    #
+    # See http://projects.puppetlabs.com/issues/12076 for the ticket tracking
+    # the fact that we should dig out the sane version of this behaviour, then
+    # implement it - where we don't risk breaking a stable release series.
+    # --daniel 2012-01-21
+    source = source.is_a?(Array) ? source.join : source.to_s
+    target = target.is_a?(Array) ? target.join : target.to_s
+
+    unless source_resource = catalog.resource(source)
+      raise ArgumentError, "Could not find resource '#{source}' for relationship on '#{target}'"
+    end
+    unless target_resource = catalog.resource(target)
+      raise ArgumentError, "Could not find resource '#{target}' for relationship from '#{source}'"
+    end
+    Puppet.debug "Adding relationship from #{source} to #{target} with '#{param_name}'"
+    if source_resource[param_name].class != Array
+      source_resource[param_name] = [source_resource[param_name]].compact
+    end
+    source_resource[param_name] << target
+  end
+end

data/lib/vendor/puppet/parser/resource/param.rb

@@ -0,0 +1,25 @@
+require 'puppet/parser/yaml_trimmer'
+
+# The parameters we stick in Resources.
+class Puppet::Parser::Resource::Param
+  include Puppet::Util
+  include Puppet::Util::Errors
+  include Puppet::Util::MethodHelper
+  include Puppet::Parser::YamlTrimmer
+
+  attr_accessor :name, :value, :source, :add, :file, :line
+
+  def initialize(hash)
+    set_options(hash)
+    requiredopts(:name, :value)
+    @name = @name.intern
+  end
+
+  def line_to_i
+    line ? Integer(line) : nil
+  end
+
+  def to_s
+    "#{self.name} => #{self.value}"
+  end
+end

data/lib/vendor/puppet/parser/resource.rb

@@ -0,0 +1,341 @@
+require 'puppet/resource'
+
+# The primary difference between this class and its
+# parent is that this class has rules on who can set
+# parameters
+class Puppet::Parser::Resource < Puppet::Resource
+  require 'puppet/parser/resource/param'
+  require 'puppet/util/tagging'
+  require 'puppet/parser/yaml_trimmer'
+  require 'puppet/resource/type_collection_helper'
+
+  include Puppet::Resource::TypeCollectionHelper
+
+  include Puppet::Util
+  include Puppet::Util::MethodHelper
+  include Puppet::Util::Errors
+  include Puppet::Util::Logging
+  include Puppet::Util::Tagging
+  include Puppet::Parser::YamlTrimmer
+
+  attr_accessor :source, :scope, :collector_id
+  attr_accessor :virtual, :override, :translated, :catalog, :evaluated
+  attr_accessor :file, :line
+
+  attr_reader :exported, :parameters
+
+  # Determine whether the provided parameter name is a relationship parameter.
+  def self.relationship_parameter?(name)
+    @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
+    @relationship_names.include?(name)
+  end
+
+  # Set up some boolean test methods
+  def translated?; !!@translated; end
+  def override?;   !!@override;   end
+  def evaluated?;  !!@evaluated;  end
+
+  def [](param)
+    param = param.intern
+    if param == :title
+      return self.title
+    end
+    if @parameters.has_key?(param)
+      @parameters[param].value
+    else
+      nil
+    end
+  end
+
+  def []=(param, value)
+    set_parameter(param, value)
+  end
+
+  def eachparam
+    @parameters.each do |name, param|
+      yield param
+    end
+  end
+
+  def environment
+    scope.environment
+  end
+
+  # Process the  stage metaparameter for a class.   A containment edge
+  # is drawn from  the class to the stage.   The stage for containment
+  # defaults to main, if none is specified.
+  def add_edge_to_stage
+    return unless self.type.to_s.downcase == "class"
+
+    unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
+      raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
+    end
+
+    self[:stage] ||= stage.title unless stage.title == :main
+    catalog.add_edge(stage, self)
+  end
+
+  # Retrieve the associated definition and evaluate it.
+  def evaluate
+    return if evaluated?
+    @evaluated = true
+    if klass = resource_type and ! builtin_type?
+      finish
+      evaluated_code = klass.evaluate_code(self)
+
+      return evaluated_code
+    elsif builtin?
+      devfail "Cannot evaluate a builtin type (#{type})"
+    else
+      self.fail "Cannot find definition #{type}"
+    end
+  end
+
+  # Mark this resource as both exported and virtual,
+  # or remove the exported mark.
+  def exported=(value)
+    if value
+      @virtual = true
+      @exported = value
+    else
+      @exported = value
+    end
+  end
+
+  # Do any finishing work on this object, called before evaluation or
+  # before storage/translation.
+  def finish
+    return if finished?
+    @finished = true
+    add_defaults
+    add_metaparams
+    add_scope_tags
+    validate
+  end
+
+  # Has this resource already been finished?
+  def finished?
+    @finished
+  end
+
+  def initialize(*args)
+    raise ArgumentError, "Resources require a scope" unless args.last[:scope]
+    super
+
+    @source ||= scope.source
+  end
+
+  # Is this resource modeling an isomorphic resource type?
+  def isomorphic?
+    if builtin_type?
+      return resource_type.isomorphic?
+    else
+      return true
+    end
+  end
+
+  # Merge an override resource in.  This will throw exceptions if
+  # any overrides aren't allowed.
+  def merge(resource)
+    # Test the resource scope, to make sure the resource is even allowed
+    # to override.
+    unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
+      raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
+    end
+    # Some of these might fail, but they'll fail in the way we want.
+    resource.parameters.each do |name, param|
+      override_parameter(param)
+    end
+  end
+
+  # Unless we're running >= 0.25, we're in compat mode.
+  def metaparam_compatibility_mode?
+    ! (catalog and ver = (catalog.client_version||'0.0.0').split(".") and (ver[0] > "0" or ver[1].to_i >= 25))
+  end
+
+  def name
+    self[:name] || self.title
+  end
+
+  # A temporary occasion, until I get paths in the scopes figured out.
+  def path
+    to_s
+  end
+
+  # Define a parameter in our resource.
+  # if we ever receive a parameter named 'tag', set
+  # the resource tags with its value.
+  def set_parameter(param, value = nil)
+    if ! value.nil?
+      param = Puppet::Parser::Resource::Param.new(
+        :name => param, :value => value, :source => self.source
+      )
+    elsif ! param.is_a?(Puppet::Parser::Resource::Param)
+      raise ArgumentError, "Must pass a parameter or all necessary values"
+    end
+
+    tag(*param.value) if param.name == :tag
+
+    # And store it in our parameter hash.
+    @parameters[param.name] = param
+  end
+
+  def to_hash
+    @parameters.inject({}) do |hash, ary|
+      param = ary[1]
+      # Skip "undef" values.
+      hash[param.name] = param.value if param.value != :undef
+      hash
+    end
+  end
+
+
+  # Create a Puppet::Resource instance from this parser resource.
+  # We plan, at some point, on not needing to do this conversion, but
+  # it's sufficient for now.
+  def to_resource
+    result = Puppet::Resource.new(type, title)
+
+    to_hash.each do |p, v|
+      if v.is_a?(Puppet::Resource)
+        v = Puppet::Resource.new(v.type, v.title)
+      elsif v.is_a?(Array)
+        # flatten resource references arrays
+        v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
+        v = v.collect do |av|
+          av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
+          av
+        end
+      end
+
+      # If the value is an array with only one value, then
+      # convert it to a single value.  This is largely so that
+      # the database interaction doesn't have to worry about
+      # whether it returns an array or a string.
+      result[p] = if v.is_a?(Array) and v.length == 1
+        v[0]
+          else
+            v
+              end
+    end
+
+    result.file = self.file
+    result.line = self.line
+    result.exported = self.exported
+    result.virtual = self.virtual
+    result.tag(*self.tags)
+
+    result
+  end
+
+  # Translate our object to a transportable object.
+  def to_trans
+    return nil if virtual?
+
+    to_resource.to_trans
+  end
+
+  # Convert this resource to a RAL resource.  We hackishly go via the
+  # transportable stuff.
+  def to_ral
+    to_resource.to_ral
+  end
+
+  private
+
+  # Add default values from our definition.
+  def add_defaults
+    scope.lookupdefaults(self.type).each do |name, param|
+      unless @parameters.include?(name)
+        self.debug "Adding default for #{name}"
+
+        @parameters[name] = param.dup
+      end
+    end
+  end
+
+  def add_backward_compatible_relationship_param(name)
+    # Skip metaparams for which we get no value.
+    return unless val = scope.lookupvar(name.to_s) and val != :undefined
+
+    # The default case: just set the value
+    set_parameter(name, val) and return unless @parameters[name]
+
+    # For relationship params, though, join the values (a la #446).
+    @parameters[name].value = [@parameters[name].value, val].flatten
+  end
+
+  # Add any metaparams defined in our scope. This actually adds any metaparams
+  # from any parent scope, and there's currently no way to turn that off.
+  def add_metaparams
+    compat_mode = metaparam_compatibility_mode?
+
+    Puppet::Type.eachmetaparam do |name|
+      next unless self.class.relationship_parameter?(name)
+      add_backward_compatible_relationship_param(name) if compat_mode
+    end
+  end
+
+  def add_scope_tags
+    if scope_resource = scope.resource
+      tag(*scope_resource.tags)
+    end
+  end
+
+  # Accept a parameter from an override.
+  def override_parameter(param)
+    # This can happen if the override is defining a new parameter, rather
+    # than replacing an existing one.
+    (set_parameter(param) and return) unless current = @parameters[param.name]
+
+    # The parameter is already set.  Fail if they're not allowed to override it.
+    unless param.source.child_of?(current.source)
+      puts caller if Puppet[:trace]
+      msg = "Parameter '#{param.name}' is already set on #{self}"
+      msg += " by #{current.source}" if current.source.to_s != ""
+      if current.file or current.line
+        fields = []
+        fields << current.file if current.file
+        fields << current.line.to_s if current.line
+        msg += " at #{fields.join(":")}"
+      end
+      msg += "; cannot redefine"
+      raise Puppet::ParseError.new(msg, param.line, param.file)
+    end
+
+    # If we've gotten this far, we're allowed to override.
+
+    # Merge with previous value, if the parameter was generated with the +>
+    # syntax.  It's important that we use a copy of the new param instance
+    # here, not the old one, and not the original new one, so that the source
+    # is registered correctly for later overrides but the values aren't
+    # implcitly shared when multiple resources are overrriden at once (see
+    # ticket #3556).
+    if param.add
+      param = param.dup
+      param.value = [current.value, param.value].flatten
+    end
+
+    set_parameter(param)
+  end
+
+  # Make sure the resource's parameters are all valid for the type.
+  def validate
+    @parameters.each do |name, param|
+      validate_parameter(name)
+    end
+  rescue => detail
+    fail Puppet::ParseError, detail.to_s
+  end
+
+  private
+
+  def extract_parameters(params)
+    params.each do |param|
+      # Don't set the same parameter twice
+      self.fail Puppet::ParseError, "Duplicate parameter '#{param.name}' for on #{self}" if @parameters[param.name]
+
+      set_parameter(param)
+    end
+  end
+end