puppet-strings 2.1.0 → 2.2.0

data/spec/unit/puppet-strings/json_spec.rb

@@ -202,28 +202,82 @@ path this type will autorequire that file.
 SOURCE
   end
 
-  let(:filename) do
-    if TEST_PUPPET_PLANS
-      'output_with_plan.json'
-    else
-      TEST_PUPPET_FUNCTIONS ? 'output.json' : 'output_without_puppet_function.json'
+  RSpec.shared_examples "correct JSON" do
+    it 'should include data for Puppet Classes' do
+      puppet_class_json = YARD::Registry.all(:puppet_class).sort_by!(&:name).map!(&:to_hash).to_json
+
+      expect(json_output).to include_json(puppet_class_json)
+    end
+
+    it 'should include data for Puppet Defined Types' do
+      defined_types_json = YARD::Registry.all(:puppet_defined_type).sort_by!(&:name).map!(&:to_hash).to_json
+
+      expect(json_output).to include_json(defined_types_json)
+    end
+
+    it 'should include data for Puppet Resouce Types' do
+      resource_types_json = YARD::Registry.all(:puppet_type).sort_by!(&:name).map!(&:to_hash).to_json
+
+      expect(json_output).to include_json(resource_types_json)
+    end
+
+    it 'should include data for Puppet Providers' do
+      providers_json = YARD::Registry.all(:puppet_provider).sort_by!(&:name).map!(&:to_hash).to_json
+
+      expect(json_output).to include_json(providers_json)
+    end
+
+    it 'should include data for Puppet Functions', if: TEST_PUPPET_FUNCTIONS do
+      puppet_functions_json = YARD::Registry.all(:puppet_function).sort_by!(&:name).map!(&:to_hash).to_json
+
+      expect(json_output).to include_json(puppet_functions_json)
+    end
+
+    it 'should include data for Puppet Tasks' do
+      puppet_tasks_json = YARD::Registry.all(:puppet_task).sort_by!(&:name).map!(&:to_hash).to_json
+
+      expect(json_output).to include_json(puppet_tasks_json)
+    end
+
+    it 'should include data for Puppet Plans', if: TEST_PUPPET_PLANS do
+      puppet_plans_json = YARD::Registry.all(:puppet_plan).sort_by!(&:name).map!(&:to_hash).to_json
+
+      expect(json_output).to include_json(puppet_plans_json)
     end
   end
-  let(:baseline_path) { File.join(File.dirname(__FILE__), "../../fixtures/unit/json/#{filename}") }
-  let(:baseline) { File.read(baseline_path) }
 
   describe 'rendering JSON to a file' do
-    it 'should output the expected JSON content' do
+    let(:json_output) do
+      json_output = nil
+
       Tempfile.open('json') do |file|
         PuppetStrings::Json.render(file.path)
-        expect(File.read(file.path)).to eq(baseline)
+
+        json_output = File.read(file.path)
       end
+
+      json_output
     end
+
+    include_examples "correct JSON"
   end
 
   describe 'rendering JSON to stdout' do
-    it 'should output the expected JSON content' do
-      expect{ PuppetStrings::Json.render(nil) }.to output(baseline).to_stdout
+    let(:json_output) { @json_output }
+
+    before(:each) do
+      output = StringIO.new
+
+      old_stdout = $stdout
+      $stdout = output
+
+      PuppetStrings::Json.render(nil)
+
+      $stdout = old_stdout
+
+      @json_output = output.string
     end
+
+    include_examples "correct JSON"
   end
 end

data/spec/unit/puppet-strings/markdown_spec.rb

@@ -108,12 +108,20 @@ SOURCE
 # @option param3 [Array] :param3opt Something about this option
 # @raise SomeError this is some error
 # @return [Undef] Returns nothing.
+# @example Test
+#   $result = func(1, 2)
 function func(Integer $param1, $param2, String $param3 = hi) {
 }
 SOURCE
 
     YARD::Parser::SourceParser.parse_string(<<-SOURCE, :ruby)
 # An example 4.x function.
+#
+# @example Calling the function
+#   $result = func4x(1, 'foo')
+#
+# @example Calling the function with all args
+#   $result = func4x(1, 'foo', ['bar'])
 Puppet::Functions.create_function(:func4x) do
   # An overview for the first overload.
   # @raise SomeError this is some error
@@ -123,6 +131,9 @@ Puppet::Functions.create_function(:func4x) do
   # @option param2 [String] :option2 another option
   # @param param3 The third parameter.
   # @return Returns nothing.
+  # @example Calling the function foo
+  #   $result = func4x(1, 'foooo')
+  #
   dispatch :foo do
     param          'Integer',       :param1
     param          'Any',           :param2
@@ -134,6 +145,8 @@ Puppet::Functions.create_function(:func4x) do
   # @param param The first parameter.
   # @param block The block parameter.
   # @return Returns a string.
+  # @example Calling the function bar
+  #   $result = func4x(1, 'bar', ['foo'])
   dispatch :other do
     param 'Boolean', :param
     block_param

data/spec/unit/puppet-strings/yard/handlers/json/task_handler_spec.rb

@@ -7,15 +7,7 @@ describe PuppetStrings::Yard::Handlers::JSON::TaskHandler do
     YARD::Registry.all(:puppet_task)
   }
 
-  describe 'parsing source without a task definition' do
-    let(:source) { 'notice hi' }
-
-    it 'no defined types should be in the registry' do
-      expect(subject.empty?).to eq(true)
-    end
-  end
-
-  describe 'parsing source with a syntax error' do
+  describe 'parsing task metadata with a syntax error' do
     let(:source) { <<-SOURCE
 {
   "input_method": "stdin",
@@ -35,7 +27,7 @@ SOURCE
     end
   end
 
-  describe 'parsing a defined type with a missing docstring' do
+  describe 'parsing task metadata with a missing description' do
     let(:source) { <<-SOURCE
 {
   "input_method": "stdin",
@@ -66,7 +58,7 @@ SOURCE
     end
   end
 
-  describe 'parsing a defined type with a docstring' do
+  describe 'parsing task metadata with a description' do
     let(:source) { <<-SOURCE
 {
   "description": "Allows you to backup your database to local file.",
@@ -102,7 +94,7 @@ SOURCE
     end
   end
 
-  describe 'parsing a Task with a missing parameter description' do
+  describe 'parsing task metadata with a missing parameter description' do
     let(:source) { <<-SOURCE
 {
   "description": "Allows you to backup your database to local file.",

data/spec/unit/puppet-strings/yard/handlers/ruby/function_handler_spec.rb

@@ -289,7 +289,7 @@ SOURCE
       }
 
       it 'does not throw an error with no @return' do
-        expect { subject }.not_to raise_error NoMethodError
+        expect { subject }.not_to raise_error
       end
 
       it 'contains a return data type' do

data/spec/unit/puppet-strings/yard/handlers/ruby/rsapi_handler_spec.rb

@@ -211,4 +211,25 @@ SOURCE
       end
     end
   end
+
+  describe 'parsing a type with title_patterns' do
+    let(:source) { <<-SOURCE
+Puppet::ResourceApi.register_type(
+  name: 'database',
+  docs: 'An example database server resource type.',
+  title_patterns: [
+    {
+      pattern: %r{(?<name>.*)},
+      desc: 'Generic title match',
+    }
+  ]
+)
+SOURCE
+    }
+
+    it 'should not emit a warning' do
+      expect{ subject }.not_to output(/\[warn\].*unexpected construct regexp_literal/).to_stdout_from_any_process
+    end
+  end
+
 end

data/spec/unit/puppet-strings/yard/handlers/ruby/type_handler_spec.rb

@@ -72,6 +72,32 @@ SOURCE
     end
   end
 
+  describe 'parsing a type with a param with arguments' do
+    let(:source) { <<-SOURCE
+Puppet::Type.newtype(:database) do
+  feature :encryption, 'The provider supports encryption.', methods: [:encrypt]
+
+  newparam(:encryption_key, :parent => Puppet::Parameter::Boolean, required_features: :encryption) do
+    desc 'The encryption key to use.'
+    defaultto false
+  end
+end
+SOURCE
+    }
+
+    it 'should correctly detect the required_feature' do
+      expect(subject.size).to eq(1)
+      object = subject.first
+      expect(object.parameters[0].required_features).to eq('encryption')
+    end
+
+    it 'should correctly detect a boolean parent' do
+      expect(subject.size).to eq(1)
+      object = subject.first
+      expect(object.parameters[0].default).to eq('false')
+    end
+  end
+
   describe 'parsing a type definition' do
     let(:source) { <<-SOURCE
 # @!puppet.type.param [value1, value2] dynamic_param Documentation for a dynamic parameter.

data/spec/unit/puppet-strings/yard/parsers/json/parser_spec.rb

@@ -6,7 +6,7 @@ describe PuppetStrings::Yard::Parsers::JSON::Parser do
   let(:file) { 'test.json' }
 
   describe 'initialization of the parser' do
-    let(:source) { 'notice hi' }
+    let(:source) { '{}' }
 
     it 'should store the original source' do
       expect(subject.source).to eq(source)
@@ -18,6 +18,7 @@ describe PuppetStrings::Yard::Parsers::JSON::Parser do
 
     it 'should have no relevant statements' do
       subject.parse
+
       expect(subject.enumerator.empty?).to be_truthy
     end
   end
@@ -34,7 +35,7 @@ SOURCE
   end
 
 
-  describe 'parsing puppet functions with return type in defintion', if: TEST_FUNCTION_RETURN_TYPE do
+  describe 'parsing valid task metadata JSON' do
     let(:source) { <<SOURCE
 {
   "description": "Allows you to backup your database to local file.",
@@ -60,8 +61,9 @@ SOURCE
 }
 SOURCE
     }
-    it 'should parse the puppet function statement' do
+    it 'should parse the JSON and extract a TaskStatement' do
       subject.parse
+
       expect(subject.enumerator.size).to eq(1)
       statement = subject.enumerator.first
       expect(statement).to be_instance_of(PuppetStrings::Yard::Parsers::JSON::TaskStatement)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-strings
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Puppet Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-26 00:00:00.000000000 Z
+date: 2019-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -60,6 +60,7 @@ files:
 - Rakefile
 - codecov.yml
 - lib/puppet-strings.rb
+- lib/puppet-strings/describe.rb
 - lib/puppet-strings/json.rb
 - lib/puppet-strings/markdown.rb
 - lib/puppet-strings/markdown/base.rb
@@ -110,6 +111,8 @@ files:
 - lib/puppet-strings/yard/handlers/ruby/function_handler.rb
 - lib/puppet-strings/yard/handlers/ruby/provider_handler.rb
 - lib/puppet-strings/yard/handlers/ruby/rsapi_handler.rb
+- lib/puppet-strings/yard/handlers/ruby/type_base.rb
+- lib/puppet-strings/yard/handlers/ruby/type_extras_handler.rb
 - lib/puppet-strings/yard/handlers/ruby/type_handler.rb
 - lib/puppet-strings/yard/parsers.rb
 - lib/puppet-strings/yard/parsers/json/parser.rb
@@ -208,13 +211,11 @@ files:
 - spec/fixtures/acceptance/modules/test/manifests/init.pp
 - spec/fixtures/acceptance/modules/test/manifests/triple_nested_classes.pp
 - spec/fixtures/acceptance/modules/test/metadata.json
-- spec/fixtures/unit/json/output.json
-- spec/fixtures/unit/json/output_with_plan.json
-- spec/fixtures/unit/json/output_without_puppet_function.json
 - spec/fixtures/unit/markdown/output.md
 - spec/fixtures/unit/markdown/output_with_plan.md
 - spec/spec_helper.rb
 - spec/spec_helper_acceptance.rb
+- spec/unit/puppet-strings/describe_spec.rb
 - spec/unit/puppet-strings/json_spec.rb
 - spec/unit/puppet-strings/markdown/base_spec.rb
 - spec/unit/puppet-strings/markdown_spec.rb
@@ -252,7 +253,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - puppet, >= 4.0.0
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Puppet documentation via YARD

data/spec/fixtures/unit/json/output.json

@@ -1,660 +0,0 @@
-{
-  "puppet_classes": [
-    {
-      "name": "klass",
-      "file": "(stdin)",
-      "line": 7,
-      "inherits": "foo::bar",
-      "docstring": {
-        "text": "A simple class.",
-        "tags": [
-          {
-            "tag_name": "todo",
-            "text": "Do a thing"
-          },
-          {
-            "tag_name": "note",
-            "text": "Some note"
-          },
-          {
-            "tag_name": "param",
-            "text": "First param.",
-            "types": [
-              "Integer"
-            ],
-            "name": "param1"
-          },
-          {
-            "tag_name": "param",
-            "text": "Second param.",
-            "types": [
-              "Any"
-            ],
-            "name": "param2"
-          },
-          {
-            "tag_name": "param",
-            "text": "Third param.",
-            "types": [
-              "String"
-            ],
-            "name": "param3"
-          }
-        ]
-      },
-      "defaults": {
-        "param3": "hi"
-      },
-      "source": "class klass(Integer $param1, $param2, String $param3 = hi) inherits foo::bar {\n}"
-    }
-  ],
-  "defined_types": [
-    {
-      "name": "dt",
-      "file": "(stdin)",
-      "line": 14,
-      "docstring": {
-        "text": "A simple defined type.",
-        "tags": [
-          {
-            "tag_name": "param",
-            "text": "First param.",
-            "types": [
-              "Integer"
-            ],
-            "name": "param1"
-          },
-          {
-            "tag_name": "param",
-            "text": "Second param.",
-            "types": [
-              "Any"
-            ],
-            "name": "param2"
-          },
-          {
-            "tag_name": "param",
-            "text": "Third param.",
-            "types": [
-              "String"
-            ],
-            "name": "param3"
-          }
-        ]
-      },
-      "defaults": {
-        "param3": "hi"
-      },
-      "source": "define dt(Integer $param1, $param2, String $param3 = hi) {\n}"
-    }
-  ],
-  "resource_types": [
-    {
-      "name": "apt_key",
-      "file": "(stdin)",
-      "line": 92,
-      "docstring": {
-        "text": "This type provides Puppet with the capabilities to manage GPG keys needed\nby apt to perform package validation. Apt has it's own GPG keyring that can\nbe manipulated through the `apt-key` command.\n**Autorequires**:\nIf Puppet is given the location of a key file which looks like an absolute\npath this type will autorequire that file.",
-        "tags": [
-          {
-            "tag_name": "summary",
-            "text": "Example resource type using the new API."
-          },
-          {
-            "tag_name": "raise",
-            "text": "SomeError"
-          },
-          {
-            "tag_name": "example",
-            "text": "apt_key { '6F6B15509CF8E59E6E469F327F438280EF8D349F':\n  source => 'http://apt.puppetlabs.com/pubkey.gpg'\n}",
-            "name": "here's an example"
-          }
-        ]
-      },
-      "properties": [
-        {
-          "name": "ensure",
-          "description": "Whether this apt key should be present or absent on the target system.",
-          "data_type": "Enum[present, absent]"
-        },
-        {
-          "name": "created",
-          "description": "Date the key was created, in ISO format.",
-          "data_type": "String"
-        }
-      ],
-      "parameters": [
-        {
-          "name": "id",
-          "description": "The ID of the key you want to manage.",
-          "data_type": "Variant[Pattern[/A(0x)?[0-9a-fA-F]{8}Z/], Pattern[/A(0x)?[0-9a-fA-F]{16}Z/], Pattern[/A(0x)?[0-9a-fA-F]{40}Z/]]",
-          "isnamevar": true
-        }
-      ]
-    },
-    {
-      "name": "database",
-      "file": "(stdin)",
-      "line": 54,
-      "docstring": {
-        "text": "An example database server resource type."
-      },
-      "properties": [
-        {
-          "name": "ensure",
-          "description": "What state the database should be in.",
-          "values": [
-            "present",
-            "absent",
-            "up",
-            "down"
-          ],
-          "aliases": {
-            "up": "present",
-            "down": "absent"
-          },
-          "default": "up"
-        },
-        {
-          "name": "file",
-          "description": "The database file to use."
-        },
-        {
-          "name": "log_level",
-          "description": "The log level to use.",
-          "values": [
-            "debug",
-            "warn",
-            "error"
-          ],
-          "default": "warn"
-        }
-      ],
-      "parameters": [
-        {
-          "name": "address",
-          "description": "The database server name.",
-          "isnamevar": true
-        },
-        {
-          "name": "encryption_key",
-          "description": "The encryption key to use."
-        },
-        {
-          "name": "encrypt",
-          "description": "Whether or not to encrypt the database.",
-          "values": [
-            "true",
-            "false",
-            "yes",
-            "no"
-          ],
-          "default": "false"
-        }
-      ],
-      "features": [
-        {
-          "name": "encryption",
-          "description": "The provider supports encryption."
-        }
-      ]
-    }
-  ],
-  "providers": [
-    {
-      "name": "linux",
-      "type_name": "database",
-      "file": "(stdin)",
-      "line": 43,
-      "docstring": {
-        "text": "An example provider on Linux."
-      },
-      "confines": {
-        "kernel": "Linux",
-        "osfamily": "RedHat"
-      },
-      "features": [
-        "implements_some_feature",
-        "some_other_feature"
-      ],
-      "defaults": [
-        [
-          [
-            "kernel",
-            "Linux"
-          ]
-        ],
-        [
-          [
-            "osfamily",
-            "RedHat"
-          ],
-          [
-            "operatingsystemmajrelease",
-            "7"
-          ]
-        ]
-      ],
-      "commands": {
-        "foo": "/usr/bin/foo"
-      }
-    }
-  ],
-  "puppet_functions": [
-    {
-      "name": "func",
-      "file": "(stdin)",
-      "line": 6,
-      "type": "puppet",
-      "signatures": [
-        {
-          "signature": "func(Integer $param1, Any $param2, String $param3 = hi)",
-          "docstring": {
-            "text": "A simple function.",
-            "tags": [
-              {
-                "tag_name": "param",
-                "text": "First param.",
-                "types": [
-                  "Integer"
-                ],
-                "name": "param1"
-              },
-              {
-                "tag_name": "param",
-                "text": "Second param.",
-                "types": [
-                  "Any"
-                ],
-                "name": "param2"
-              },
-              {
-                "tag_name": "param",
-                "text": "Third param.",
-                "types": [
-                  "String"
-                ],
-                "name": "param3"
-              },
-              {
-                "tag_name": "return",
-                "text": "Returns nothing.",
-                "types": [
-                  "Undef"
-                ]
-              }
-            ]
-          }
-        }
-      ],
-      "docstring": {
-        "text": "A simple function.",
-        "tags": [
-          {
-            "tag_name": "param",
-            "text": "First param.",
-            "types": [
-              "Integer"
-            ],
-            "name": "param1"
-          },
-          {
-            "tag_name": "param",
-            "text": "Second param.",
-            "types": [
-              "Any"
-            ],
-            "name": "param2"
-          },
-          {
-            "tag_name": "param",
-            "text": "Third param.",
-            "types": [
-              "String"
-            ],
-            "name": "param3"
-          },
-          {
-            "tag_name": "return",
-            "text": "Returns nothing.",
-            "types": [
-              "Undef"
-            ]
-          }
-        ]
-      },
-      "defaults": {
-        "param3": "hi"
-      },
-      "source": "function func(Integer $param1, $param2, String $param3 = hi) {\n}"
-    },
-    {
-      "name": "func3x",
-      "file": "(stdin)",
-      "line": 1,
-      "type": "ruby3x",
-      "signatures": [
-        {
-          "signature": "func3x(String $first, Any $second)",
-          "docstring": {
-            "text": "An example 3.x function.",
-            "tags": [
-              {
-                "tag_name": "param",
-                "text": "The first parameter.",
-                "types": [
-                  "String"
-                ],
-                "name": "first"
-              },
-              {
-                "tag_name": "param",
-                "text": "The second parameter.",
-                "types": [
-                  "Any"
-                ],
-                "name": "second"
-              },
-              {
-                "tag_name": "return",
-                "text": "Returns nothing.",
-                "types": [
-                  "Undef"
-                ]
-              }
-            ]
-          }
-        }
-      ],
-      "docstring": {
-        "text": "An example 3.x function.",
-        "tags": [
-          {
-            "tag_name": "param",
-            "text": "The first parameter.",
-            "types": [
-              "String"
-            ],
-            "name": "first"
-          },
-          {
-            "tag_name": "param",
-            "text": "The second parameter.",
-            "types": [
-              "Any"
-            ],
-            "name": "second"
-          },
-          {
-            "tag_name": "return",
-            "text": "Returns nothing.",
-            "types": [
-              "Undef"
-            ]
-          }
-        ]
-      },
-      "source": "Puppet::Parser::Functions.newfunction(:func3x, doc: <<-DOC\nAn example 3.x function.\n@param [String] first The first parameter.\n@param second The second parameter.\n@return [Undef] Returns nothing.\nDOC\n) do |*args|\nend"
-    },
-    {
-      "name": "func4x",
-      "file": "(stdin)",
-      "line": 11,
-      "type": "ruby4x",
-      "signatures": [
-        {
-          "signature": "func4x(Integer $param1, Any $param2, Optional[Array[String]] $param3)",
-          "docstring": {
-            "text": "The first overload.",
-            "tags": [
-              {
-                "tag_name": "param",
-                "text": "The first parameter.",
-                "types": [
-                  "Integer"
-                ],
-                "name": "param1"
-              },
-              {
-                "tag_name": "param",
-                "text": "The second parameter.",
-                "types": [
-                  "Any"
-                ],
-                "name": "param2"
-              },
-              {
-                "tag_name": "param",
-                "text": "The third parameter.",
-                "types": [
-                  "Optional[Array[String]]"
-                ],
-                "name": "param3"
-              },
-              {
-                "tag_name": "return",
-                "text": "Returns nothing.",
-                "types": [
-                  "Undef"
-                ]
-              }
-            ]
-          }
-        },
-        {
-          "signature": "func4x(Boolean $param, Callable &$block)",
-          "docstring": {
-            "text": "",
-            "tags": [
-              {
-                "tag_name": "param",
-                "text": "The first parameter.",
-                "types": [
-                  "Boolean"
-                ],
-                "name": "param"
-              },
-              {
-                "tag_name": "param",
-                "text": "The block parameter.",
-                "types": [
-                  "Callable"
-                ],
-                "name": "&block"
-              },
-              {
-                "tag_name": "return",
-                "text": "Returns a string.",
-                "types": [
-                  "String"
-                ]
-              }
-            ]
-          }
-        }
-      ],
-      "docstring": {
-        "text": "An example 4.x function.",
-        "tags": [
-          {
-            "tag_name": "overload",
-            "signature": "func4x(Integer $param1, Any $param2, Optional[Array[String]] $param3)",
-            "docstring": {
-              "text": "The first overload.",
-              "tags": [
-                {
-                  "tag_name": "param",
-                  "text": "The first parameter.",
-                  "types": [
-                    "Integer"
-                  ],
-                  "name": "param1"
-                },
-                {
-                  "tag_name": "param",
-                  "text": "The second parameter.",
-                  "types": [
-                    "Any"
-                  ],
-                  "name": "param2"
-                },
-                {
-                  "tag_name": "param",
-                  "text": "The third parameter.",
-                  "types": [
-                    "Optional[Array[String]]"
-                  ],
-                  "name": "param3"
-                },
-                {
-                  "tag_name": "return",
-                  "text": "Returns nothing.",
-                  "types": [
-                    "Undef"
-                  ]
-                }
-              ]
-            },
-            "name": "func4x"
-          },
-          {
-            "tag_name": "overload",
-            "signature": "func4x(Boolean $param, Callable &$block)",
-            "docstring": {
-              "text": "",
-              "tags": [
-                {
-                  "tag_name": "param",
-                  "text": "The first parameter.",
-                  "types": [
-                    "Boolean"
-                  ],
-                  "name": "param"
-                },
-                {
-                  "tag_name": "param",
-                  "text": "The block parameter.",
-                  "types": [
-                    "Callable"
-                  ],
-                  "name": "&block"
-                },
-                {
-                  "tag_name": "return",
-                  "text": "Returns a string.",
-                  "types": [
-                    "String"
-                  ]
-                }
-              ]
-            },
-            "name": "func4x"
-          }
-        ]
-      },
-      "source": "Puppet::Functions.create_function(:func4x) do\n  # The first overload.\n  # @param param1 The first parameter.\n  # @param param2 The second parameter.\n  # @param param3 The third parameter.\n  # @return Returns nothing.\n  dispatch :foo do\n    param          'Integer',       :param1\n    param          'Any',           :param2\n    optional_param 'Array[String]', :param3\n    return_type 'Undef'\n  end\n\n  # @param param The first parameter.\n  # @param block The block parameter.\n  # @return Returns a string.\n  dispatch :other do\n    param 'Boolean', :param\n    block_param\n    return_type 'String'\n  end\nend"
-    },
-    {
-      "name": "func4x_1",
-      "file": "(stdin)",
-      "line": 35,
-      "type": "ruby4x",
-      "signatures": [
-        {
-          "signature": "func4x_1(Integer $param1)",
-          "docstring": {
-            "text": "An example 4.x function with only one signature.",
-            "tags": [
-              {
-                "tag_name": "param",
-                "text": "The first parameter.",
-                "types": [
-                  "Integer"
-                ],
-                "name": "param1"
-              },
-              {
-                "tag_name": "return",
-                "text": "Returns nothing.",
-                "types": [
-                  "Undef"
-                ]
-              }
-            ]
-          }
-        }
-      ],
-      "docstring": {
-        "text": "An example 4.x function with only one signature.",
-        "tags": [
-          {
-            "tag_name": "param",
-            "text": "The first parameter.",
-            "types": [
-              "Integer"
-            ],
-            "name": "param1"
-          },
-          {
-            "tag_name": "return",
-            "text": "Returns nothing.",
-            "types": [
-              "Undef"
-            ]
-          }
-        ]
-      },
-      "source": "Puppet::Functions.create_function(:func4x_1) do\n  # @param param1 The first parameter.\n  # @return [Undef] Returns nothing.\n  dispatch :foobarbaz do\n    param          'Integer',       :param1\n  end\nend"
-    }
-  ],
-  "puppet_tasks": [
-    {
-      "name": "(stdin)",
-      "file": "(stdin)",
-      "line": 0,
-      "docstring": {
-        "text": "Allows you to backup your database to local file.",
-        "tags": [
-          {
-            "name": "database",
-            "tag_name": "param",
-            "text": "Database to connect to",
-            "types": [
-              "Optional[String[1]]"
-            ]
-          },
-          {
-            "name": "user",
-            "tag_name": "param",
-            "text": "The user",
-            "types": [
-              "Optional[String[1]]"
-            ]
-          },
-          {
-            "name": "password",
-            "tag_name": "param",
-            "text": "The password",
-            "types": [
-              "Optional[String[1]]"
-            ]
-          },
-          {
-            "name": "sql",
-            "tag_name": "param",
-            "text": "Path to file you want backup to",
-            "types": [
-              "String[1]"
-            ]
-          }
-        ]
-      },
-      "source": "{\n  \"description\": \"Allows you to backup your database to local file.\",\n  \"input_method\": \"stdin\",\n  \"parameters\": {\n    \"database\": {\n      \"description\": \"Database to connect to\",\n      \"type\": \"Optional[String[1]]\"\n    },\n    \"user\": {\n      \"description\": \"The user\",\n      \"type\": \"Optional[String[1]]\"\n    },\n    \"password\": {\n      \"description\": \"The password\",\n      \"type\": \"Optional[String[1]]\"\n    },\n     \"sql\": {\n      \"description\": \"Path to file you want backup to\",\n      \"type\": \"String[1]\"\n    }\n  }\n}\n",
-      "supports_noop": false,
-      "input_method": "stdin"
-    }
-  ],
-  "puppet_plans": [
-
-  ]
-}