kafo_parsers 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b30e88b47bab4b2e93f985edad54bbaf15d39f88
+  data.tar.gz: e55504058e7761a4007713304e4fa7f170aec79e
+SHA512:
+  metadata.gz: dda98ff6406272517880053973c475be3edd7ceeebd9133996fd0ba0a31f03d20f9ea36502f20149a9fdcaa22d5b5964fbd35c7ffc96bf964c5e5956501af570
+  data.tar.gz: 4bc186885a9e4a0890343741c85bc8049bd26c18a3ed94cccf4aeb4d8e4d00f4a3dc8c48289012397ee3ccdf643835e2d4c2592d81113dbdfc6f37664102aeb5

data/LICENSE.txt

@@ -0,0 +1,11 @@
+This program and entire repository is free software: you can redistribute it 
+and/or modify it under the terms of the GNU General Public License as 
+published by the Free Software Foundation, either version 3 of the License, 
+or any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT 
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with 
+this program. If not, see http://www.gnu.org/licenses/.

data/README.md

@@ -0,0 +1,32 @@
+# KafoParsers
+
+This gem can parse values, validations, documentation, types, groups and
+conditions of parameters from your puppet modules. Only thing you have
+to do is provide a path to manifest file you want to be parsed.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'kafo_parsers'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kafo_parsers
+
+## Usage
+
+To parse file and see parsed information
+```ruby
+require 'kafo_parsers/kafo_module_parser'
+hash = KafoParsers::KafoModuleParser.parse('/puppet/module/manifests/init.pp')
+p hash
+```
+
+# License
+
+This project is licensed under the GPLv3+.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+require "bundler/gem_tasks"
+load 'tasks/jenkins.rake'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+

data/lib/kafo_parsers.rb

@@ -0,0 +1 @@
+require 'kafo_parsers/version'

data/lib/kafo_parsers/doc_parser.rb

@@ -0,0 +1,129 @@
+# encoding: UTF-8
+require 'rdoc'
+require 'rdoc/markup' # required for RDoc < 0.9.5
+require 'rdoc/markup/parser' # required for RDoc < 0.9.5
+
+module KafoParsers
+  class DocParser
+    ATTRIBUTE_LINE   = /^(condition|type)\s*:\s*(.*)/
+    HEADER_CONDITION = /\A(.+)\s*condition:\s*(.+)\Z/
+
+    def initialize(text)
+      @text           = text
+      @nesting_buffer = []
+      @docs           = {}
+      @groups         = {}
+      @conditions     = {}
+      @types          = Hash.new('string')
+      @rdoc           = rdoc_parser.parse(@text)
+    end
+
+    attr_reader :docs, :groups, :types, :conditions
+
+    # items is array of RDoc::Markup::* on one level
+    def parse(items = @rdoc.parts)
+      items.each do |item|
+        if item.is_a?(RDoc::Markup::Heading)
+          parse_header(item)
+        elsif item.is_a?(RDoc::Markup::List) && item.respond_to?(:items)
+          parse(item.items)
+        elsif item.is_a?(RDoc::Markup::ListItem)
+          parse_paragraph(item)
+        end
+      end
+      self
+    end
+
+    private
+
+    def parse_paragraph(para)
+      # Skip rdoc paras that aren't paragraphs
+      return unless (para.parts.to_s.scan("RDoc::Markup::Paragraph") == ["RDoc::Markup::Paragraph"])
+      # RDoc (>= 4) makes label an array
+      label = para.label.is_a?(Array) ? para.label.first : para.label
+      # Documentation must be a list - if there's no label then skip
+      return if label.nil?
+      key              = label.gsub(/[^A-Za-z0-9_-]/, '')
+      @groups[key]     = current_groups
+      text_parts       = para.parts.first.parts.map!(&:strip)
+      attributes, docs = text_parts.partition { |line| line =~ ATTRIBUTE_LINE }
+      parse_attributes(key, attributes)
+      @docs[key] = docs
+    end
+
+    def parse_attributes(parameter, attributes)
+      condition = nil
+      attributes.each do |attribute|
+        data        = attribute.match(ATTRIBUTE_LINE)
+        name, value = data[1], data[2]
+
+        case name
+          when 'type'
+            @types[parameter] = value
+          when 'condition'
+            if condition.nil?
+              condition = value
+            else
+              raise DocParseError, "Two or more conditions defined for #{name}"
+            end
+          else
+            raise DocParseError, "Unknown attribute #{name}"
+        end
+
+      end
+      condition              = [current_condition, condition].compact.join(' && ')
+      @conditions[parameter] = condition.empty? ? nil : condition
+    end
+
+    def parse_header(heading)
+      if heading.level > current_level
+        @nesting_buffer.push nesting(heading)
+      elsif heading.level == current_level
+        @nesting_buffer.pop
+        @nesting_buffer.push nesting(heading)
+      else
+        while current_level >= heading.level do
+          @nesting_buffer.pop
+        end
+        @nesting_buffer.push nesting(heading)
+      end
+    end
+
+    def nesting(heading)
+      if heading.text =~ HEADER_CONDITION
+        text, condition = $1, $2
+      else
+        text, condition = heading.text, nil
+      end
+      Nesting.new(text.strip, heading.level, condition)
+    end
+
+    def current_groups
+      @nesting_buffer.map(&:name)
+    end
+
+    def current_level
+      current_nesting.nil? ? 0 : current_nesting.level
+    end
+
+    def current_condition
+      condition = @nesting_buffer.map(&:condition).select { |c| !c.nil? }.join(' && ')
+      condition.empty? ? nil : condition
+    end
+
+    def current_nesting
+      @nesting_buffer.last
+    end
+
+    def rdoc_parser
+      if RDoc::Markup.respond_to?(:parse)
+        RDoc::Markup
+      else # RDoc < 3.10.0
+        RDoc::Markup::Parser
+      end
+    end
+
+    class Nesting < Struct.new(:name, :level, :condition);
+    end
+  end
+end

data/lib/kafo_parsers/exceptions.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+module KafoParsers
+  class DocParseError < StandardError
+  end
+
+  class ModuleName < StandardError
+  end
+
+end

data/lib/kafo_parsers/puppet_module_parser.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+require 'puppet'
+require 'kafo_parsers/doc_parser'
+
+module KafoParsers
+  # Based on ideas from puppet-parse by Johan van den Dorpe
+  # we don't build any tree structure since e.g. params from doc does not
+  # have to be defined in puppet DSL and vice versa, we just gather all info
+  # we can read from the whole manifest
+  class PuppetModuleParser
+    # You can call this method to get all supported information from a given manifest
+    #
+    # @param [ String ] manifest file path to parse
+    # @return [ Hash ] hash containing values, validations, documentation, types, groups and conditions
+    def self.parse(file)
+      content = new(file)
+      docs    = content.docs
+
+      data              = {
+          :values      => content.values,
+          :validations => content.validations
+      }
+      data[:parameters] = data[:values].keys
+      data.merge!(docs)
+      data
+    end
+
+    def initialize(file)
+      @file = file
+      raise ModuleName, "File not found #{file}, check you answer file" unless File.exists?(file)
+      Puppet.settings[:confdir] ||= '/' # just some stubbing
+      if Puppet::Node::Environment.respond_to?(:create)
+        env = Puppet::Node::Environment.create(:production, [], '')
+      else
+        env = Puppet::Node::Environment.new(:production)
+      end
+      parser = Puppet::Parser::Parser.new(env)
+      parser.import(@file)
+
+      # Find object corresponding to class defined in init.pp in list of hostclasses
+      parser.environment.known_resource_types.hostclasses.each do |ast_objects|
+        ast_type = ast_objects.last
+        @object = ast_type if ast_type.file == file
+      end
+
+      parser
+    end
+
+    # TODO - store parsed object type (Puppet::Parser::AST::Variable must be dumped later)
+    def values
+      parameters = {}
+      arguments  = @object.respond_to?(:arguments) ? @object.arguments : {}
+      arguments.each { |k, v| parameters[k] = v.respond_to?(:value) ? v.value : nil }
+      parameters
+    end
+
+    def validations(param = nil)
+      @object.code.select { |stmt| stmt.is_a?(Puppet::Parser::AST::Function) && stmt.name =~ /^validate_/ }
+    end
+
+    # returns data in following form
+    # {
+    #   :docs => { $param1 => 'documentation without types and conditions'}
+    #   :types => { $param1 => 'boolean'},
+    #   :groups => { $param1 => ['Parameters', 'Advanced']},
+    #   :conditions => { $param1 => '$db_type == "mysql"'},
+    # }
+    def docs
+      data = { :docs => {}, :types => {}, :groups => {}, :conditions => {} }
+      if @object.nil?
+        raise DocParseError, "no documentation found for manifest #{@file}, parsing error?"
+      elsif !@object.doc.nil?
+        parser            = DocParser.new(@object.doc).parse
+        data[:docs]       = parser.docs
+        data[:groups]     = parser.groups
+        data[:types]      = parser.types
+        data[:conditions] = parser.conditions
+      end
+      data
+    end
+  end
+end

data/lib/kafo_parsers/version.rb

@@ -0,0 +1,3 @@
+module KafoParsers
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: kafo_parsers
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Marek Hulan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ci_reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: puppet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+description: This gem can parse values, validations, documentation, types, groups
+  and conditions of parameters from your puppet modules
+email:
+- mhulan@redhat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/kafo_parsers/puppet_module_parser.rb
+- lib/kafo_parsers/doc_parser.rb
+- lib/kafo_parsers/exceptions.rb
+- lib/kafo_parsers/version.rb
+- lib/kafo_parsers.rb
+- LICENSE.txt
+- Rakefile
+- README.md
+homepage: https://github.com/theforeman/kafo_parsers
+licenses:
+- GPLv3+
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Puppet module parsers
+test_files: []
+has_rdoc: