puppet-strings 2.4.0 → 2.5.0

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

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'puppet-strings/yard'
-
-describe PuppetStrings::Yard::Parsers::JSON::Parser do
-  subject { PuppetStrings::Yard::Parsers::JSON::Parser.new(source, file) }
-  let(:file) { 'test.json' }
-
-  describe 'initialization of the parser' do
-    let(:source) { '{}' }
-
-    it 'should store the original source' do
-      expect(subject.source).to eq(source)
-    end
-
-    it 'should store the original file name' do
-      expect(subject.file).to eq(file)
-    end
-
-    it 'should have no relevant statements' do
-      subject.parse
-
-      expect(subject.enumerator.empty?).to be_truthy
-    end
-  end
-
-  describe 'parsing invalid JSON' do
-    let(:source) { <<SOURCE
-class foo {
-SOURCE
-    }
-
-    it 'should raise an exception' do
-      expect{ subject.parse }.to output(/\[error\]: Failed to parse test.json/).to_stdout_from_any_process
-    end
-  end
-
-
-  describe 'parsing valid task metadata JSON' do
-    let(:source) { <<SOURCE
-{
-  "description": "Allows you to backup your database to local file.",
-  "input_method": "stdin",
-  "parameters": {
-    "database": {
-      "description": "Database to connect to",
-      "type": "Optional[String[1]]"
-    },
-    "user": {
-      "description": "The user",
-      "type": "Optional[String[1]]"
-    },
-    "password": {
-      "description": "The password",
-      "type": "Optional[String[1]]"
-    },
-     "sql": {
-      "description": "Path to file you want backup to",
-      "type": "String[1]"
-    }
-  }
-}
-SOURCE
-    }
-    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)
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-describe PuppetStrings::Yard::Parsers::JSON::TaskStatement do
-  let(:source) { <<-SOURCE
-{
-  "description": "Allows you to backup your database to local file.",
-  "input_method": "stdin",
-  "parameters": {
-    "database": {
-      "description": "Database to connect to",
-      "type": "Optional[String[1]]"
-    },
-    "user": {
-      "description": "The user",
-      "type": "Optional[String[1]]"
-    },
-    "password": {
-      "description": "The password",
-      "type": "Optional[String[1]]"
-    },
-     "sql": {
-      "description": "Path to file you want backup to",
-      "type": "String[1]"
-    }
-  }
-}
-  SOURCE
-  }
-  let(:json) { JSON.parse(source) }
-  subject { PuppetStrings::Yard::Parsers::JSON::TaskStatement.new(json, source, "test.json") }
-  describe '#comments' do
-    it 'returns docstring' do
-      expect(subject.comments).to eq "Allows you to backup your database to local file."
-    end
-  end
-  describe '#parameters' do
-    context 'with params' do
-      it 'returns params' do
-        expect(subject.parameters.size > 0).to be true
-      end
-    end
-    context 'no params' do
-      let(:source) { <<-SOURCE
-{
-  "description": "Allows you to backup your database to local file.",
-  "input_method": "stdin"
-}
-      SOURCE
-      }
-      it 'returns an empty hash' do
-        expect(subject.parameters).to eq({})
-      end
-    end
-  end
-
-end

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

@@ -1,251 +0,0 @@
-require 'spec_helper'
-require 'puppet-strings/yard'
-
-describe PuppetStrings::Yard::Parsers::Puppet::Parser do
-  subject { PuppetStrings::Yard::Parsers::Puppet::Parser.new(source, file) }
-  let(:file) { 'test.pp' }
-
-  describe 'initialization of the parser' do
-    let(:source) { 'notice hi' }
-
-    it 'should store the original source' do
-      expect(subject.source).to eq(source)
-    end
-
-    it 'should store the original file name' do
-      expect(subject.file).to eq(file)
-    end
-
-    it 'should have no relevant statements' do
-      subject.parse
-      expect(subject.enumerator.empty?).to be_truthy
-    end
-  end
-
-  describe 'parsing invalid Puppet source code' do
-    let(:source) { <<SOURCE
-class foo {
-SOURCE
-    }
-
-    it 'should raise an exception' do
-      expect{ subject.parse }.to output(/\[error\]: Failed to parse test.pp: Syntax error at end of (file|input)/).to_stdout_from_any_process
-    end
-  end
-
-  describe 'parsing class definitions' do
-    let(:source) { <<SOURCE
-notice hello
-# A simple foo class.
-# @param param1 First param.
-# @param param2 Second param.
-# @param param3 Third param.
-class foo(Integer $param1, $param2, String $param3 = hi) inherits foo::bar {
-  file { '/tmp/foo':
-    ensure => present
-  }
-}
-SOURCE
-    }
-
-    it 'should only return the class statement' do
-      subject.parse
-      expect(subject.enumerator.size).to eq(1)
-      statement = subject.enumerator.first
-      expect(statement).to be_a(PuppetStrings::Yard::Parsers::Puppet::ClassStatement)
-      expect(statement.source).to eq("class foo(Integer $param1, $param2, String $param3 = hi) inherits foo::bar {\n  file { '/tmp/foo':\n    ensure => present\n  }\n}")
-      expect(statement.file).to eq(file)
-      expect(statement.line).to eq(6)
-      expect(statement.docstring).to eq('A simple foo class.')
-      expect(statement.name).to eq('foo')
-      expect(statement.parent_class).to eq('foo::bar')
-      expect(statement.parameters.size).to eq(3)
-      expect(statement.parameters[0].name).to eq('param1')
-      expect(statement.parameters[0].type).to eq('Integer')
-      expect(statement.parameters[0].value).to be_nil
-      expect(statement.parameters[1].name).to eq('param2')
-      expect(statement.parameters[1].type).to be_nil
-      expect(statement.parameters[1].value).to be_nil
-      expect(statement.parameters[2].name).to eq('param3')
-      expect(statement.parameters[2].type).to eq('String')
-      expect(statement.parameters[2].value).to eq('hi')
-    end
-  end
-
-  describe 'parsing nested class definitions' do
-    let(:source) { <<SOURCE
-class foo {
-  class bar {
-  }
-}
-SOURCE
-    }
-
-    it 'should parse both class statements' do
-      subject.parse
-      expect(subject.enumerator.size).to eq(2)
-      statement = subject.enumerator[0]
-      expect(statement).to be_a(PuppetStrings::Yard::Parsers::Puppet::ClassStatement)
-      expect(statement.name).to eq('foo::bar')
-      expect(statement.parameters.size).to eq(0)
-      statement = subject.enumerator[1]
-      expect(statement).to be_a(PuppetStrings::Yard::Parsers::Puppet::ClassStatement)
-      expect(statement.name).to eq('foo')
-      expect(statement.parameters.size).to eq(0)
-    end
-  end
-
-  describe 'parsing defined types' do
-    let(:source) { <<SOURCE
-notice hello
-# A simple foo defined type.
-# @param param1 First param.
-# @param param2 Second param.
-# @param param3 Third param.
-define foo(Integer $param1, $param2, String $param3 = hi) {
-  file { '/tmp/foo':
-    ensure => present
-  }
-}
-SOURCE
-    }
-
-    it 'should parse the defined type statement' do
-      subject.parse
-      expect(subject.enumerator.size).to eq(1)
-      statement = subject.enumerator.first
-      expect(statement).to be_a(PuppetStrings::Yard::Parsers::Puppet::DefinedTypeStatement)
-      expect(statement.name).to eq('foo')
-      expect(statement.source).to eq("define foo(Integer $param1, $param2, String $param3 = hi) {\n  file { '/tmp/foo':\n    ensure => present\n  }\n}")
-      expect(statement.file).to eq(file)
-      expect(statement.line).to eq(6)
-      expect(statement.docstring).to eq('A simple foo defined type.')
-      expect(statement.parameters.size).to eq(3)
-      expect(statement.parameters[0].name).to eq('param1')
-      expect(statement.parameters[0].type).to eq('Integer')
-      expect(statement.parameters[0].value).to be_nil
-      expect(statement.parameters[1].name).to eq('param2')
-      expect(statement.parameters[1].type).to be_nil
-      expect(statement.parameters[1].value).to be_nil
-      expect(statement.parameters[2].name).to eq('param3')
-      expect(statement.parameters[2].type).to eq('String')
-      expect(statement.parameters[2].value).to eq('hi')
-    end
-  end
-
-  describe 'parsing puppet functions', if: TEST_PUPPET_FUNCTIONS do
-    let(:source) { <<SOURCE
-notice hello
-# A simple foo function.
-# @param param1 First param.
-# @param param2 Second param.
-# @param param3 Third param.
-function foo(Integer $param1, $param2, String $param3 = hi) {
-  notice world
-}
-SOURCE
-    }
-
-    it 'should parse the puppet function statement' do
-      subject.parse
-      expect(subject.enumerator.size).to eq(1)
-      statement = subject.enumerator.first
-      expect(statement).to be_a(PuppetStrings::Yard::Parsers::Puppet::FunctionStatement)
-      expect(statement.name).to eq('foo')
-      expect(statement.source).to eq("function foo(Integer $param1, $param2, String $param3 = hi) {\n  notice world\n}")
-      expect(statement.file).to eq(file)
-      expect(statement.line).to eq(6)
-      expect(statement.docstring).to eq('A simple foo function.')
-      expect(statement.parameters.size).to eq(3)
-      expect(statement.parameters[0].name).to eq('param1')
-      expect(statement.parameters[0].type).to eq('Integer')
-      expect(statement.parameters[0].value).to be_nil
-      expect(statement.parameters[1].name).to eq('param2')
-      expect(statement.parameters[1].type).to be_nil
-      expect(statement.parameters[1].value).to be_nil
-      expect(statement.parameters[2].name).to eq('param3')
-      expect(statement.parameters[2].type).to eq('String')
-      expect(statement.parameters[2].value).to eq('hi')
-    end
-  end
-
-  describe 'parsing puppet functions with return type in defintion', if: TEST_FUNCTION_RETURN_TYPE do
-    let(:source) { <<SOURCE
-  # A simple foo function.
-  # @return Returns a string
-  function foo() >> String {
-    notice world
-  }
-SOURCE
-    }
-
-    it 'should parse the puppet function statement' do
-      subject.parse
-      expect(subject.enumerator.size).to eq(1)
-      statement = subject.enumerator.first
-      expect(statement).to be_a(PuppetStrings::Yard::Parsers::Puppet::FunctionStatement)
-      expect(statement.type).to eq('String')
-    end
-  end
-
-  describe 'parsing puppet functions with complex return types in defintion', if: TEST_FUNCTION_RETURN_TYPE do
-    let(:source) { <<SOURCE
-  # A simple foo function.
-  # @return Returns a struct with a hash including one key which must be an integer between 1 and 10.
-  function foo() >> Struct[{'a' => Integer[1, 10]}] {
-    notice world
-  }
-SOURCE
-    }
-
-    it 'should parse the puppet function statement' do
-      subject.parse
-      expect(subject.enumerator.size).to eq(1)
-      statement = subject.enumerator.first
-      expect(statement).to be_a(PuppetStrings::Yard::Parsers::Puppet::FunctionStatement)
-      expect(statement.type).to eq("Struct\[{'a' => Integer[1, 10]}\]")
-    end
-  end
-
-  describe 'parsing type alias definitions', if: TEST_PUPPET_DATATYPES do
-    context 'given a type alias on a single line' do
-      let(:source) { <<-SOURCE
-# A simple foo type.
-type Module::Typename = Variant[Stdlib::Windowspath, Stdlib::Unixpath]
-SOURCE
-      }
-
-      it 'should parse the puppet type statement' do
-        subject.parse
-        expect(subject.enumerator.size).to eq(1)
-        statement = subject.enumerator.first
-        expect(statement).to be_a(PuppetStrings::Yard::Parsers::Puppet::DataTypeAliasStatement)
-        expect(statement.docstring).to eq('A simple foo type.')
-        expect(statement.name).to eq('Module::Typename')
-        expect(statement.alias_of).to eq('Variant[Stdlib::Windowspath, Stdlib::Unixpath]')
-      end
-    end
-
-    context 'given a type alias over multiple lines' do
-      let(:source) { <<-SOURCE
-# A multiline foo type
-# with long docs
-type OptionsWithoutName = Struct[{
-  value_type => Optional[ValueType],
-  merge      => Optional[MergeType]
-}]
-SOURCE
-      }
-
-      it 'should parse the puppet type statement' do
-        subject.parse
-        expect(subject.enumerator.size).to eq(1)
-        statement = subject.enumerator.first
-        expect(statement).to be_a(PuppetStrings::Yard::Parsers::Puppet::DataTypeAliasStatement)
-        expect(statement.docstring).to eq("A multiline foo type\nwith long docs")
-        expect(statement.name).to eq('OptionsWithoutName')
-        expect(statement.alias_of).to eq("Struct[{\n  value_type => Optional[ValueType],\n  merge      => Optional[MergeType]\n}]")
-      end
-    end
-  end
-end

data/spec/unit/puppet-strings/yard/util_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-require 'puppet-strings/yard'
-
-describe PuppetStrings::Yard::Util do
-  subject {PuppetStrings::Yard::Util}
-
-  describe 'scrub_string' do
-    it 'should remove `%Q` and its brackets from a string ' do
-      str = "%Q{this is a test string}"
-      expect(subject.scrub_string(str)).to eq('this is a test string')
-    end
-
-    it 'should remove `%q` and its brackets from a string' do
-      str = "%q{this is a test string}"
-      expect(subject.scrub_string(str)).to eq('this is a test string')
-    end
-
-    it 'should not affect newlines when %Q notation is used' do
-      str = <<-STR
-%Q{this is
-a test string}
-      STR
-      expect(subject.scrub_string(str)).to eq("this is\na test string")
-    end
-
-    it 'should not affect a string which does not use %Q notation' do
-      str = "this is a test string"
-      expect(subject.scrub_string(str)).to eq('this is a test string')
-    end
-  end
-
-  describe 'github_to_yard_links' do
-    it 'converts a link correctly' do
-      str = '<a href="#module-description">'
-      expect(subject.github_to_yard_links(str)).to eq('<a href="#label-Module+description">')
-    end
-
-    it 'leaves other links with hashes alone' do
-      str = '<a href="www.github.com/blah/document.html#module-description">'
-      expect(subject.github_to_yard_links(str)).to eq(str)
-    end
-
-    it 'leaves plain text alone' do
-      str = '<a href="#module-description"> module-description'
-      expect(subject.github_to_yard_links(str)).to eq('<a href="#label-Module+description"> module-description')
-    end
-  end
-end