openvox 8.19.0

data/lib/puppet/util/rdoc/code_objects.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require 'rdoc/code_objects'
+
+module RDoc
+  # This modules contains various class that are used to hold information
+  # about the various Puppet language structures we found while parsing.
+  #
+  # Those will be mapped to their html counterparts which are defined in
+  # PuppetGenerator.
+
+  # PuppetTopLevel is a top level (usually a .pp/.rb file)
+  module PuppetTopLevel
+    attr_accessor :module_name, :global
+  end
+
+  # Add top level comments to a class or module
+  # @api private
+  module AddClassModuleComment
+    def add_comment(comment, location = nil)
+      super
+    end
+  end
+
+  # PuppetModule holds a Puppet Module
+  # This is mapped to an HTMLPuppetModule
+  # it leverage the RDoc (ruby) module infrastructure
+  class PuppetModule < NormalModule
+    include AddClassModuleComment
+
+    attr_accessor :facts, :plugins
+
+    def initialize(name, superclass = nil)
+      @facts = []
+      @plugins = []
+      @nodes = {}
+      super(name, superclass)
+    end
+
+    def add_plugin(plugin)
+      name = plugin.name
+      type = plugin.type
+      meth = AnyMethod.new("*args", name)
+      meth.params = "(*args)"
+      meth.visibility = :public
+      meth.document_self = true
+      meth.singleton = false
+      meth.comment = plugin.comment
+      case type
+      when 'function'
+        @function_container ||= add_module(NormalModule, "__functions__")
+        @function_container.add_method(meth)
+      when 'type'
+        @type_container ||= add_module(NormalModule, "__types__")
+        @type_container.add_method(meth)
+      end
+    end
+
+    def add_fact(fact)
+      @fact_container ||= add_module(NormalModule, "__facts__")
+      confine_str = fact.confine.empty? ? '' : fact.confine.to_s
+      const = Constant.new(fact.name, confine_str, fact.comment)
+      @fact_container.add_constant(const)
+    end
+
+    # Adds a module called __nodes__ and adds nodes to it as classes
+    #
+    def add_node(name, superclass)
+      cls = @nodes[name]
+      if cls
+        return cls
+      end
+
+      @node_container ||= add_module(NormalModule, "__nodes__")
+      cls = @node_container.add_class(PuppetNode, name, superclass)
+      @nodes[name] = cls unless @done_documenting
+      cls
+    end
+
+    def each_fact
+      @facts.each { |c| yield c }
+    end
+
+    def each_plugin
+      @plugins.each { |c| yield c }
+    end
+
+    def each_node
+      @nodes.each { |c| yield c }
+    end
+
+    def nodes
+      @nodes.values
+    end
+  end
+
+  # PuppetClass holds a puppet class
+  # It is mapped to a HTMLPuppetClass for display
+  # It leverages RDoc (ruby) Class
+  class PuppetClass < ClassModule
+    include AddClassModuleComment
+
+    attr_accessor :resource_list, :requires, :childs, :realizes
+
+    def initialize(name, superclass)
+      super(name, superclass)
+      @resource_list = []
+      @requires = []
+      @realizes = []
+      @childs = []
+    end
+
+    def aref_prefix
+      'puppet_class'
+    end
+
+    def add_resource(resource)
+      add_to(@resource_list, resource)
+    end
+
+    def is_module?
+      false
+    end
+
+    def superclass=(superclass)
+      @superclass = superclass
+    end
+
+    # we're (ab)using the RDoc require system here.
+    # we're adding a required Puppet class, overriding
+    # the RDoc add_require method which sees ruby required files.
+    def add_require(required)
+      add_to(@requires, required)
+    end
+
+    def add_realize(realized)
+      add_to(@realizes, realized)
+    end
+
+    def add_child(child)
+      @childs << child
+    end
+
+    # Look up the given symbol. RDoc only looks for class1::class2.method
+    # or class1::class2#method. Since our definitions are mapped to RDoc methods
+    # but are written class1::class2::define we need to perform the lookup by
+    # ourselves.
+    def find_symbol(symbol, method = nil)
+      result = super(symbol)
+      if !result and symbol =~ /::/
+        modules = symbol.split(/::/)
+        unless modules.empty?
+          module_name = modules.shift
+          result = find_module_named(module_name)
+          if result
+            last_name = ""
+            previous = nil
+            modules.each do |mod|
+              previous = result
+              last_name = mod
+              result = result.find_module_named(mod)
+              break unless result
+            end
+            unless result
+              result = previous
+              method = last_name
+            end
+          end
+        end
+        if result && method
+          unless result.respond_to?(:find_local_symbol)
+            p result.name
+            p method
+            fail
+          end
+          result = result.find_local_symbol(method)
+        end
+      end
+      result
+    end
+  end
+
+  # PuppetNode holds a puppet node
+  # It is mapped to a HTMLPuppetNode for display
+  # A node is just a variation of a class
+  class PuppetNode < PuppetClass
+    include AddClassModuleComment
+
+    def is_module?
+      false
+    end
+  end
+
+  # Plugin holds a native puppet plugin (function,type...)
+  # It is mapped to a HTMLPuppetPlugin for display
+  class Plugin < Context
+    attr_accessor :name, :type
+
+    def initialize(name, type)
+      super()
+      @name = name
+      @type = type
+      @comment = ""
+    end
+
+    def <=>(other)
+      @name <=> other.name
+    end
+
+    def full_name
+      @name
+    end
+
+    def http_url(prefix)
+      path = full_name.split("::")
+      File.join(prefix, *path) + ".html"
+    end
+
+    def is_fact?
+      false
+    end
+
+    def to_s
+      res = self.class.name + ": #{@name} (#{@type})\n"
+      res << @comment.to_s
+      res
+    end
+  end
+
+  # Fact holds a custom fact
+  # It is mapped to a HTMLPuppetPlugin for display
+  class Fact < Context
+    attr_accessor :name, :confine
+
+    def initialize(name, confine)
+      super()
+      @name = name
+      @confine = confine
+      @comment = ""
+    end
+
+    def <=>(other)
+      @name <=> other.name
+    end
+
+    def is_fact?
+      true
+    end
+
+    def full_name
+      @name
+    end
+
+    def to_s
+      res = self.class.name + ": #{@name}\n"
+      res << @comment.to_s
+      res
+    end
+  end
+
+  # PuppetResource holds a puppet resource
+  # It is mapped to a HTMLPuppetResource for display
+  # A resource is defined by its "normal" form Type[title]
+  class PuppetResource < CodeObject
+    attr_accessor :type, :title, :params
+
+    def initialize(type, title, comment, params)
+      super()
+      @type = type
+      @title = title
+      @comment = comment
+      @params = params
+    end
+
+    def <=>(other)
+      full_name <=> other.full_name
+    end
+
+    def full_name
+      @type + "[#{@title}]"
+    end
+
+    def name
+      full_name
+    end
+
+    def to_s
+      res = @type + "[#{@title}]\n"
+      res << @comment.to_s
+      res
+    end
+  end
+end