yaml_bot 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 690221476263c104a55fcb15652246b4d0c1428b
-  data.tar.gz: fda86ec2dc086f27d78953d0e6e8b58c736e0cff
+  metadata.gz: 8169550325022501a33fe951c691a0814d753666
+  data.tar.gz: b28c4b536c226f143f5b8d50abca65e76b0cd1aa
 SHA512:
-  metadata.gz: ea1a7373f40b3e1f3e98fb39c4b6c4fe625833f76abbf99f95c1e5767aac6fbafca4c5a79f7f1902041bff80c2e38ecb017796e28be70dd4c3dba45b861054f1
-  data.tar.gz: 4abf76ffb38580f9291d879f4d3f15943bed69853d596dc46db58e89a60646cd36e568402a7b7fb15ecf15171856a758098629c1d7090d67169fcfd8cb1e0e48
+  metadata.gz: 8bf5698a4b75356806147d63b08535b38bd70a1d2753157a5030b7351c75fff3fd0321cede33d222013091d7fd81e5e94271b03fae53811aed99556724f98ed4
+  data.tar.gz: fbabbe2ba0d1c910e61ca5f735027b013be3e7ef2fe5bf7b12572e8742ccdbbea6b84e24cf01dad1b4f73143e70956322f13a54f5794bc26918807e27d727345

data/.gitignore

@@ -9,3 +9,4 @@
 /tmp/
 *.gem
 *.log
+.yamlbot.yml

data/.rubocop.yml

@@ -4,7 +4,21 @@ Documentation:
 # Metrics/MethodLength:
 #   Max: 15
 
+Metrics/LineLength:
+  # This will disable the rule completely, regardless what other options you put
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  # Strings in Ruby 2.3 >= are frozen by default
+  Enabled: false
+
 Metrics/ClassLength:
   Enabled: false
   CountComments: false  # count full line comments?
   Max: 100
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/CyclomaticComplexity:
+  Max: 7

data/.ruby-version

@@ -1 +1 @@
-2.2.5
+2.4.1

data/.travis.yml

@@ -1,8 +1,7 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.2.5
-  - 2.3.1
+  - 2.4.1
 before_install: gem install bundler -v 1.13.0
 script:
   - bundle exec rake

data/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+# v0.3.0 - 2017-06-06
+### Changed
+- Redefined the YamlBot rules specification according to [issue 22](https://github.com/skippyPeanutButter/yaml_bot/issues/22).
+- Reimplemented the YamlBot API to handle new rules specification.
+- Changed required ruby version to be >= 2.4.
+
 # v0.2.0 - 2017-01-14
 ### Added
 - `values` key has been added to the [Yamlbot Specification][values].

data/README.md

@@ -11,13 +11,18 @@ YamlBot is not a Yaml linter, it is a Yaml format validator.
 
 Mistakes can often be made when working with yaml-based configuration. Systems
 such as travis-ci, rubocop, and other tools that utilize yaml files to govern
-how they work often present users with a multitude of keys that can take on
-many possible values. `yamlbot` allows you to feed it a set of rules that a
-yaml-based system follows and then validate any yaml file against those rules.
+how they work often present users with a multitude of keys and options that can
+take on many possible values. `yamlbot` allows users to feed it a set of rules
+that a yaml-based system follows and then validate any yaml file against those
+rules.
 
-If you have a tool that works off of a yaml configuration then you can craft
-your own [`.yamlbot.yml` file][yamlbot-spec], share it with others, and have
-them use `yamlbot` to validate their config against your specified rules.
+If a tool works off of a yaml-based configuration then a rules file can be
+crafted for validating the configuration is correct. Create a rules file, share
+it with others, and have them use `yamlbot` to validate their configuration
+against the specified rules.
+
+See the [RULES FILE](RULES_DEFINITION.md) specification for details on creating
+a `.yamlbot.yml` rules file.
 
 ### Installation
 
@@ -38,7 +43,7 @@ Or install it yourself as:
 ### Usage
 
 Create a `.yamlbot.yml` file with a set of rules that you want to validate yaml
-files against [yamlbot file specification][yamlbot-spec].
+files against [yamlbot file specification](RULES_DEFINITION.md).
 
 Usage assuming the existence `.yamlbot.yml` in the current directory:
 
@@ -84,5 +89,3 @@ to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 The gem is available as open source under the terms of the [MIT
 License](http://opensource.org/licenses/MIT).
-
-[yamlbot-spec]: https://github.com/skippyPeanutButter/yaml_bot/wiki/Rules-file-specification

data/RULES_DEFINITION.md

@@ -0,0 +1,259 @@
+# YAMLBOT RULES DEFINITION
+
+This document details YamlBot rules specification. Using the details discussed
+below, users can craft their own `.yamlbot.yml` rules for validating yaml-based
+files according to a specification. Examples of yaml-based tools that can be
+validated include [travis-ci](https://travis-ci.org/),
+[rubocop](https://github.com/bbatsov/rubocop), and
+[jervis](https://github.com/samrocketman/jervis).
+
+The general layout of a `.yamlbot.yml` file is as follows:
+
+```yaml
+defaults:
+  'default values for rules'
+rules:
+  - key: 'yaml.address'
+    required_key: true|false
+    and_requires: ['list of yaml addresses']
+    or_requires: ['list of yaml addresses']
+    value_whitelist: ['list of values']
+    value_blacklist: ['list of values']
+    types: ['list of types']
+```
+
+### Key definitions
+
+- `defaults` - This section of the rules file is where default values can be
+  specified for the keys `required_key`, `and_requires`,
+  `or_requires`, `value_whitelist`, `value_blacklist`, and 'types'.
+  This key is optional if a user does not wish to specify defaults.
+
+  Note: Specific values defined under individual keys will override
+  any default values.
+
+- `rules` - This section is where the rules for yaml file validation are
+  specified. This key is required for `YamlBot` to successfully parse
+  the rules file.
+
+- `key` - This key is *required*. A rules file must be made up of a
+  list of keys that need to be validated. `key` requires a string value,
+  which denotes the name of the key being validated. If a user desires
+  to validate a nested key, then `.` delimiter must be used to denote
+  the parent-child relationship of nested keys.
+
+  Example:
+  Sample .yamlbot.yml
+
+  ```yaml
+    rules:
+      - key: person.age
+        required_key: true
+        types: [number]
+  ```
+
+  Sample yaml file being validated
+
+  ```yaml
+    person:
+      age: 43
+  ```
+
+  Nested keys can be specified up to `nth` level of nesting using the
+  `.` delimiter.
+
+- `required_key` - This key is *required* only if it is not defined in
+  the `defaults` section. Every key in the list of key being
+  validated must be specified as required or not.
+
+- `and_requires` - This key is optional. It determines additional keys that
+  *must* be part of the yaml file being validated if a
+  particular key is defined.
+
+  Example:
+  ```yaml
+  rules:
+   - key: keya
+     required_key: false
+     and_requires: [keyb]
+  ```
+  The above rules specifies that if `keya` is defined in the
+  yaml file being validated, then `keyb` must also be defined
+  for the yaml file to be successfully validated.
+
+- `or_requires` - This key is optional, if a particular key is a required_key
+  and is missing, then a yaml file may still be valid if any of
+  the keys in the `or_requires` list exists and is properly
+  defined.
+
+  Example:
+  ```yaml
+  rules:
+    - key: keya
+      required_key: true
+      and_requires: [keyb]
+  ```
+  The above rules specifies that if `keya` is required in the
+  yaml file being validated and is missing, then the yaml file
+  will still be marked as valid if `keyb` exists in the yaml
+  file with a valid value.
+
+- `value_whitelist` - This key is optional. It defines a list of possible values
+  that a key may take on. If this list is defined and a key
+  does not have a value specified within this list then that
+  key will fail validation.
+
+- `value_blacklist` - This key is optional. It defines a list of values that a
+  key may *not* take on. If this list is defined and a key
+  has a value defined in this list, then that key will fail
+  validation.
+
+- `types` - This key is optional. It defines a list of the possible data types
+  that a key's value may be.
+  Possible types include 'list', 'object', 'string', 'boolean',
+  'number'.
+
+  Example:
+  ```yaml
+  - key: age
+    required_key: true
+    types: [number]
+  - key: ethnicity
+    required_key: false
+    types: [string, list]
+  ```
+
+  Types are denoted in yaml as follows.
+
+  *List*
+  key `groceries` takes an array of items as its value
+
+  ```yaml
+    groceries:
+      - apples
+      - bananas
+      - carrots
+    or
+
+    groceries: [apples, bananas, carrots]
+  ```
+
+  *Object*
+  key `car` takes a map/hash of keys with their own values
+
+  ```yaml
+    car:
+      wheels: 4
+      transmission: automatic
+      color: blue
+  ```
+
+  *String*
+  key 'name' takes a string literal as its value
+
+  ```yaml
+    name: Louis
+  ```
+
+  *Boolean*
+  key `can_fly` takes a boolean as its value
+
+  ```yaml
+    can_fly: false
+  ```
+
+  *Number*
+  key `age` takes an integer number as its value
+  key `price` takes a floating point number as its value
+
+  ```yaml
+    age: 2
+    price: 3.99
+  ```
+### Examples
+
+The examples that follow specify several sample yaml files and their accompanying
+`.yamlbot.yml` files used to validate them.
+
+```yaml
+defaults:
+  required_key: true
+rules:
+  - key: person
+    types: [object]
+  - key: person.name
+    types: [string]
+  - key: person.age
+    types: [number]
+  - key: person.haircolor
+    required_key: false
+    types: [string]
+  - key: person.race
+    types: [string]
+    value_whitelist: [dwarf, highelf, human, orc, hobbit]
+```
+
+```yaml
+person:
+  name: Frodo
+  age: 20
+  race: hobbit
+```
+
+The above yaml file would pass validation due to defining all of the required
+keys with valid values.
+
+---
+
+```yaml
+defaults:
+  required_key: false
+  types: [string, list]
+rules:
+  - key: language
+    types: [string]
+    value_whitelist: [c, go, java, objective-c, python, ruby, swift]
+  - key: before_install
+  - key: install
+  - key: before_script
+  - key: script
+```
+
+```yaml
+language: java
+install:
+  - export JAVA_HOME='/usr/bin/java1.8/'
+  - mvn install
+script: mvn test
+```
+
+The above yaml file would pass validation due to defining all of the keys with
+valid values. Although, an empty yaml file would've passed validation due to
+no keys being marked as *required* in the `defaults` section.
+
+---
+
+```yaml
+rules:
+  - key: bookshelf_items
+    required_key: true
+    types: [string, list]
+  - key: toybox_items
+    required_key: false
+    types: [string, list]
+    value_blacklist: [legos, barbies, hotwheels]
+```
+
+```yaml
+toybox:
+  - 'barbies'
+  - 'batman'
+  - 'beanie baby'
+bookshelf_items:
+  - 'Brittanica Encyclopedia'
+  - 'How to adult for dummies'
+  - 'YAML for beginners'
+```
+
+The above yaml file would fail validation due to defining the `toybox_items`
+key with a blacked listed value.

data/bin/yamlbot

@@ -26,6 +26,10 @@ parser = OptionParser.new do |opts|
     options[:file] = file
   end
 
+  # opts.on('-c', '--no-color', 'Disable colored output') do
+  #   options[:no_color] = true
+  # end
+
   opts.on('-h', '--help', 'help') do
     puts parser
     exit

data/lib/yaml_bot/cli_bot.rb

@@ -1,8 +1,6 @@
 require 'yaml'
-require 'yaml_bot/logging_bot'
 require 'yaml_bot/rules_bot'
 require 'yaml_bot/validation_bot'
-require 'active_support/core_ext/hash/keys'
 
 module YamlBot
   class CLIBot
@@ -10,91 +8,65 @@ module YamlBot
 
     def initialize(opts = {})
       @options = opts
-      log_file = File.new('yaml_bot.log', 'w')
-      @logger_bot = LoggingBot.new(log_file)
       @rules_bot = RulesBot.new
       @validation_bot = ValidationBot.new
     end
 
     def run
       check_cli_options
-      load_rules_file
-      load_yaml_file
-      load_logger
-      check_rules_file
-      scan_yaml_file
+      load_rules
+      load_yaml
+      validate_rules
+      scan_yaml
       print_results
       @validation_bot.violations.zero? ? 0 : 1
-    ensure
-      @logger_bot.close_log
     end
 
     private
 
-    def load_rules_file
-      if @options[:rules].nil?
-        load_default_rules
+    def print_results
+      if @validation_bot.violations.positive?
+        puts pluralize(@validation_bot.violations,
+                       'violation',
+                       'violations')
       else
-        load_custom_rules
+        puts "#{@validation_bot.violations} violations"
       end
     end
 
-    def load_yaml_file
-      yaml_file = YAML.load(File.open(@options[:file])).deep_symbolize_keys
-      @validation_bot.yaml_file = yaml_file
-    rescue StandardError => e
-      $stderr.puts "Unable to locate yaml file #{@options[:file]}..."
-      $stderr.puts e.message
-      $stderr.puts e.backtrace
+    def load_rules
+      rules_file = @options[:rules] || '.yamlbot.yml'
+      raise IOError unless File.exist?(rules_file)
+      rules = YAML.load_file(rules_file)
+      @rules_bot.rules = rules
+      @validation_bot.rules = rules
+    rescue IOError
+      $stderr.puts "Unable to locate file: #{rules_file}"
+      $stderr.puts 'Create a .yamlbot.yml file in the current directory'
+      $stderr.puts 'or specify a rules file with the -r option'
       exit 1
     end
 
-    def load_logger
-      @rules_bot.logger = @logger_bot
-      @validation_bot.logger = @logger_bot
+    def load_yaml
+      raise StandardError, 'No YAML file specified' if @options[:file].nil?
+      raise IOError unless File.exist?(@options[:file])
+      @validation_bot.yaml_file = YAML.load_file(@options[:file])
+    rescue IOError
+      $stderr.puts "Unable to locate file: #{@options[:file]}"
+      $stderr.puts 'Pass a YAML file to validate with the -f option'
+      exit 1
     end
 
-    def check_rules_file
+    def validate_rules
+      puts 'Validating rules file...'
       @rules_bot.validate_rules
+      puts "Rules file validated...\n\n"
     end
 
-    def scan_yaml_file
-      @logger_bot.info 'Beginning scan...'
+    def scan_yaml
+      puts 'Beginning scan...'
       @validation_bot.scan
-      @logger_bot.info 'Finished scanning...'
-    end
-
-    def print_results
-      if @validation_bot.violations > 0
-        @logger_bot.error pluralize(@validation_bot.violations,
-                                    'violation',
-                                    'violations')
-      else
-        @logger_bot.info "#{@validation_bot.violations} violations"
-      end
-      puts "Results logged to #{File.absolute_path(@logger_bot.log_file.path)}"
-    end
-
-    def load_default_rules
-      rules_file = YAML.load(File.open('.yamlbot.yml')).deep_symbolize_keys
-      @rules_bot.rules = rules_file
-      @validation_bot.rules = rules_file
-    rescue StandardError
-      $stderr.puts 'Unable to locate .yamlbot.yml file...'
-      $stderr.puts 'Create a .yamlbot.yml file in the current directory'
-      $stderr.puts 'or specify a rules file with the -r option.'
-      exit 1
-    end
-
-    def load_custom_rules
-      rules_file = YAML.load(File.open(@options[:rules])).deep_symbolize_keys
-      @rules_bot.rules = rules_file
-      @validation_bot.rules = rules_file
-    rescue StandardError => e
-      $stderr.puts "Unable to locate rules file #{options[:rules]}..."
-      $stderr.puts e.message
-      $stderr.puts e.backtrace
-      exit 1
+      puts "Finished scan...\n\n"
     end
 
     def pluralize(n, singular, plural = nil)
@@ -119,6 +91,7 @@ module YamlBot
         "\t-r, --rule-file rules\t\tThe rules you will be evaluating your "\
         'yaml against',
         "\t-f, --file file\t\t\tThe file to validate against",
+        # "\t-c, --color\t\t\tEnable colored output",
         "\t-h, --help\t\t\thelp"
       ].join("\n")
       puts msg

data/lib/yaml_bot/key_bot.rb

@@ -0,0 +1,117 @@
+require 'yaml_bot/parse_bot'
+
+module YamlBot
+  class KeyBot
+    attr_accessor :defaults, :invalid, :key, :yaml_file
+
+    TYPE_MAP = {
+      object: Hash,
+      list: Array,
+      string: String,
+      number: [Integer, Float],
+      boolean: [TrueClass, FalseClass]
+    }.freeze
+
+    VALIDATION_CHECKS = [
+      :check_if_key_is_required,
+      :check_and_requires,
+      :check_or_requires,
+      :check_val_whitelist,
+      :check_val_blacklist,
+      :check_types
+    ].freeze
+
+    def initialize(key, yaml_file, defaults)
+      @defaults = defaults || {}
+      @invalid = false
+      @key = @defaults.merge(key)
+      @yaml_file = yaml_file
+    end
+
+    def validate
+      VALIDATION_CHECKS.each do |method|
+        send(method)
+        break if @invalid
+      end
+      @invalid ? 1 : 0
+    end
+
+    def check_if_key_is_required
+      yaml_key = ParseBot.get_object_value(yaml_file, key['key'])
+      return unless key['required_key'] && yaml_key.nil?
+      return unless key['or_requires'].nil?
+      @invalid = true
+      puts "VIOLATION: Missing required key: #{key['key']}"
+    end
+
+    def check_and_requires
+      yaml_key = ParseBot.get_object_value(yaml_file, key['key'])
+      return if yaml_key.nil? || key['and_requires'].nil?
+      key['and_requires'].each do |k|
+        next unless ParseBot.get_object_value(yaml_file, k).nil?
+        @invalid = true
+        puts "VIOLATION: Key #{key['key']} requires that the following key(s)"
+        puts "also be defined: #{key['and_requires']}"
+        break
+      end
+    end
+
+    # If the key being checked, or any of
+    # the keys in the "or_requires" list
+    # are in the yaml then check passes
+    def check_or_requires
+      return if key['or_requires'].nil?
+      alt_key = search_for_alternate_key(key)
+      value = ParseBot.get_object_value(yaml_file, key['key'])
+      @invalid = value.nil? && alt_key.nil?
+      return unless @invalid
+      puts "VIOLATION: Key #{key['key']} or the following key(s)"
+      puts "must be defined: #{key['and_requires']}"
+    end
+
+    def check_val_whitelist
+      return if key['value_whitelist'].nil?
+      value = ParseBot.get_object_value(yaml_file, key['key'])
+      return if key['value_whitelist'].include?(value)
+      @invalid = true
+      puts "VIOLATION: Invalid value #{value} for whitelist #{key['value_whitelist']}\n"
+    end
+
+    def check_val_blacklist
+      return if key['value_blacklist'].nil?
+      value = ParseBot.get_object_value(yaml_file, key['key'])
+      return unless key['value_blacklist'].include?(value)
+      @invalid = true
+      puts "VIOLATION: Blacklisted value specified #{value}\n"
+    end
+
+    def check_types
+      return if key['types'].nil?
+      value = ParseBot.get_object_value(yaml_file, key['key'])
+      return if value.nil?
+      @invalid = !value_is_a_valid_type?(key['types'], value)
+      return unless @invalid
+      puts "VIOLATION: Invalid value type specified for key: #{key['key']}"
+      puts "#{value.class} given, valid types include #{key['types']}\n"
+    end
+
+    private
+
+    def search_for_alternate_key(key_map)
+      alt_key = nil
+      key_map['or_requires'].each do |k|
+        alt_key = ParseBot.get_object_value(yaml_file, k)
+        return alt_key unless alt_key.nil?
+      end
+      alt_key
+    end
+
+    def value_is_a_valid_type?(types, value)
+      types.any? do |type|
+        type_value = TYPE_MAP[type.downcase.to_sym]
+        return type_value.any? { |t| value.instance_of?(t) } if type_value.instance_of?(Array)
+        return true if value.instance_of?(type_value)
+      end
+    end
+  end
+end

data/lib/yaml_bot/logging_bot.rb

@@ -16,9 +16,10 @@ module YamlBot
 
     attr_accessor :log_file, :log_level
 
-    def initialize(log_file, level = :info)
+    def initialize(log_file, level: :info, no_color: false)
       @log_file = log_file
       @log_level = level.to_sym unless valid_log_level(level)
+      @no_color = no_color
     end
 
     def info(message)
@@ -50,9 +51,9 @@ module YamlBot
     def emit(opts = {})
       color   = opts[:color]
       message = opts[:message]
-      print ESCAPES[color]
+      print ESCAPES[color] unless @no_color
       print message
-      print ESCAPES[:reset]
+      print ESCAPES[:reset] unless @no_color
       print "\n"
     end
 

data/lib/yaml_bot/parse_bot.rb

@@ -0,0 +1,22 @@
+module YamlBot
+  class ParseBot
+    def self.get_object_value(yaml, key_addr)
+      if !key_addr.index('.').nil? && key_addr.index('.') >= 0
+        key1, key2 = key_addr.split('.', 2)
+        return get_object_value(yaml[key1], key2) if !yaml[key1].nil? && yaml[key1].instance_of?(Hash)
+        return nil
+      end
+
+      return to_boolean(yaml[key_addr]) if %w(true false).include?(yaml[key_addr])
+      yaml[key_addr]
+    rescue StandardError => e
+      puts "Caught exception #{e}!"
+    end
+
+    private_class_method
+
+    def self.to_boolean(val)
+      val == 'true'
+    end
+  end
+end

data/lib/yaml_bot/resources/valid_rules_keys.yml

@@ -0,0 +1,8 @@
+---
+- key
+- required_key
+- and_requires
+- or_requires
+- value_whitelist
+- value_blacklist
+- types

data/lib/yaml_bot/resources/valid_types.yml

@@ -0,0 +1,6 @@
+---
+- object
+- list
+- string
+- number
+- boolean

data/lib/yaml_bot/rules_bot.rb

@@ -1,115 +1,70 @@
 require 'yaml'
-require 'yaml_bot/logging_bot'
 require 'yaml_bot/validation_error'
 
 module YamlBot
   class RulesBot
-    attr_accessor :rules, :logger
+    attr_accessor :rules
 
-    def initialize
-      @rules = nil
-      @missing_required_keys = false
-      @missing_optional_keys = false
+    def initialize(rules = nil)
+      @rules = rules
     end
 
     def validate_rules
-      fail_if_rules_are_not_loaded
-      validate_root_keys
-      check_top_level_keys
-      logger.info 'Rules file validated.'
-    end
-
-    private
-
-    def check_top_level_keys
-      [:required, :optional].each do |key_type|
-        next if determine_key_type(key_type)
-        @rules[:root_keys][key_type].each do |key|
-          name = key.keys.first
-          check_subkeys_and_accepted_types(key[name])
-        end
-      end
-    end
-
-    def check_subkeys_and_accepted_types(key)
-      validate_accepted_types(key) unless key[:accepted_types].nil?
-      validate_keys(key[:subkeys]) unless key[:subkeys].nil?
-    end
-
-    def determine_key_type(key_type)
-      if key_type == :required
-        @missing_required_keys
+      raise ValidationError, '.yamlbot rules file is not set.' if @rules.nil?
+      raise ValidationError, 'rules section not defined in .yamlbot file' if @rules['rules'].nil?
+      validate_rules_keys(@rules['defaults']) unless @rules['defaults'].nil?
+      if @rules['rules'].instance_of?(Array)
+        validate_each_key_rule
       else
-        @missing_optional_keys
+        msg = "The rules section of a rules file must define a list of keys.\n"
+        raise ValidationError, msg
       end
     end
 
-    def validate_root_keys
-      check_existance_of_root_keys_key
-      check_existance_of_required_and_optional_keys
-      fail_validation_if_missing_required_and_optional_keys
-    end
-
-    def check_existance_of_root_keys_key
-      return unless @rules[:root_keys].nil?
-      msg = "Missing 'root_keys' key\n"
-      msg += "Rules file must specify 'root_keys' as the top level key\n"
-      logger.error msg
-      raise YamlBot::ValidationError, msg
-    end
+    private
 
-    def check_existance_of_required_and_optional_keys
-      [:required, :optional].each do |key_type|
-        if !@rules[:root_keys].instance_of?(Hash) ||
-           @rules[:root_keys][key_type].nil?
-          log_missing_key_type(key_type)
-        end
+    def validate_each_key_rule
+      @rules['rules'].each do |key_map|
+        validate_key_map(key_map)
+        puts "Key: #{key_map['key']} validated."
       end
     end
 
-    def log_missing_key_type(key_type)
-      if key_type == :required
-        @missing_required_keys = true
-        logger.info 'No required keys specified.'
-      else
-        @missing_optional_keys = true
-        logger.info 'No optional keys specified.'
-      end
+    def validate_key_map(key_map)
+      validate_rules_keys(key_map)
+      validate_key_exists_and_is_string(key_map)
+      validate_required_key_exists_and_is_bool(key_map)
     end
 
-    def fail_validation_if_missing_required_and_optional_keys
-      return unless @missing_required_keys && @missing_optional_keys
-      msg = "Missing both required and optional root keys.\n"
-      msg += "Rules file must include at least one of those keys.\n"
-      raise YamlBot::ValidationError, msg
+    def validate_rules_keys(key_map)
+      valid_keys = YAML.load_file(File.dirname(File.realpath(__FILE__)) +
+                   '/resources/valid_rules_keys.yml')
+      invalid_keys = []
+      key_map.keys.each { |k| invalid_keys << k unless valid_keys.include?(k) }
+      return if invalid_keys.empty?
+      msg = "Invalid key(s) specified in rules file: #{invalid_keys}\n"
+      msg += "Valid rules keys include: #{valid_keys}\n"
+      raise ValidationError, msg
     end
 
-    def validate_keys(rules)
-      [:required, :optional].each do |key_type|
-        next if rules[key_type].nil?
-        rules[key_type].each do |key|
-          check_subkeys_and_accepted_types(key)
-        end
-      end
+    def validate_key_exists_and_is_string(key_map)
+      return unless key_map['key'].nil? || !key_map['key'].instance_of?(String)
+      msg = "Missing required key 'key' within rules file.\n"
+      msg += "Or a key name has a value that is not a String.\n"
+      raise ValidationError, msg
     end
 
-    def fail_if_rules_are_not_loaded
-      return unless @rules.nil? && @rules.instance_of?(Hash)
-      msg = 'Cannot validate, rules file not loaded!'
-      raise YamlBot::ValidationError, msg
+    def validate_required_key_exists_and_is_bool(key_map)
+      merged_keys = {}.merge(key_map)
+      merged_keys = @rules['defaults'].merge(key_map) unless @rules['defaults'].nil?
+      return unless merged_keys['required_key'].nil? || !boolean?(merged_keys['required_key'])
+      msg = "Missing required key 'required_key' for key: #{key_map['key']}.\n"
+      msg += "Or 'required_key' has a value that is not a Boolean.\n"
+      raise ValidationError, msg
     end
 
-    def validate_accepted_types(key_hash)
-      file_name = File.dirname(File.realpath(__FILE__)) +
-                  '/resources/valid_accepted_types.yml'
-      allowed_values = YAML.load(File.open(file_name))
-
-      key_hash[:accepted_types].each do |type|
-        next if allowed_values.include?(type)
-        msg = "Invalid value for key: #{type}\n"
-        msg += "Valid key values are #{allowed_values}"
-        raise YamlBot::ValidationError, msg
-      end
+    def boolean?(arg)
+      arg.instance_of?(TrueClass) || arg.instance_of?(FalseClass)
     end
   end
 end

data/lib/yaml_bot/validation_bot.rb

@@ -1,111 +1,23 @@
 require 'yaml'
-require 'yaml_bot/logging_bot'
-require 'yaml_bot/rules_bot'
-require 'yaml_bot/validation_error'
+require 'yaml_bot/key_bot'
 
 module YamlBot
   class ValidationBot
-    attr_accessor :rules, :yaml_file, :violations, :logger
+    attr_accessor :rules, :yaml_file, :violations
 
-    def initialize
-      self.violations = 0
+    def initialize(rules = nil, yaml_file = nil)
+      @rules = rules || {}
+      @yaml_file = yaml_file || {}
+      @violations = 0
     end
 
     def scan
-      validate_existance_of_rules_and_yaml_files
-      [:required, :optional].each do |key_type|
-        next if rules[:root_keys][key_type].nil?
-        validate_keys yaml_file, rules[:root_keys][key_type], [], key_type
+      defaults = rules['defaults']
+      rules['rules'].each do |item|
+        key_bot = KeyBot.new(item, yaml_file, defaults)
+        @violations += key_bot.validate
       end
-    end
-
-    private
-
-    def validate_keys(yaml, keys, parent_keys, key_type)
-      keys.each_with_index do |key_map, index|
-        key = key_map.keys.first
-        ancestors = parent_keys.dup << key
-        if yaml.keys.include?(key)
-          validate_subkeys_or_accepted_types(yaml, key, keys, index, ancestors)
-        else
-          log_missing_key(key_type, ancestors)
-        end
-      end
-    end
-
-    def validate_subkeys_or_accepted_types(yaml, key, keys, index, ancestors)
-      if !keys[index][key][:subkeys].nil?
-        validate_subkeys(yaml, key, keys, index, ancestors)
-      else
-        validate_accepted_types_or_key_values(yaml[key],
-                                              keys[index][key],
-                                              ancestors)
-      end
-    end
-
-    def validate_subkeys(yaml, key, keys, index, ancestors)
-      [:required, :optional].each do |key_type|
-        next if keys[index][key][:subkeys][key_type].nil?
-        validate_keys(yaml[key],
-                      keys[index][key][:subkeys][key_type],
-                      ancestors,
-                      key_type)
-      end
-    end
-
-    def validate_accepted_types_or_key_values(value, key_block, ancestors)
-      types = key_block[:accepted_types]
-      key_values = key_block[:values]
-      validate_key_values(value, key_values, ancestors) unless key_values.nil?
-      validate_accepted_types(value, types, ancestors) unless types.nil?
-    end
-
-    def validate_existance_of_rules_and_yaml_files
-      return unless rules.nil? || yaml_file.nil?
-      msg = "Rules file, or Yaml file is not set\n"
-      raise YamlBot::ValidationError, msg
-    end
-
-    def validate_accepted_types(value, types, ancestors)
-      if types.include?(value.class.to_s)
-        msg = "Key: '#{ancestors.join('.')}' contains a value of a valid type "\
-              "#{value.class}"
-        log_successful_key_validation(msg)
-      else
-        msg = "Value: '#{value}' of class #{value.class} is not a valid type "\
-              "for key: '#{ancestors.join('.')}'\n"
-        msg += "Valid types for key '#{ancestors.join('.')}' include #{types}\n"
-        log_failed_key_validation(msg)
-      end
-    end
-
-    def validate_key_values(value, key_values, ancestors)
-      if key_values.include?('*') || key_values.include?(value)
-        msg = "Key: '#{ancestors.join('.')}' contains valid value #{value}"
-        log_successful_key_validation(msg)
-      else
-        msg = "Key: '#{ancestors.join('.')}' contains invalid value #{value}\n"
-        msg += "Valid values include #{key_values}"
-        log_failed_key_validation(msg)
-      end
-    end
-
-    def log_missing_key(key_type, ancestors)
-      if key_type == :required
-        self.violations += 1
-        logger.error "Missing required key: '#{ancestors.join('.')}'"
-      else
-        logger.warn "Optional key: '#{ancestors.join('.')}' not utilized"
-      end
-    end
-
-    def log_successful_key_validation(msg)
-      logger.info msg
-    end
-
-    def log_failed_key_validation(msg)
-      self.violations += 1
-      logger.error msg
+      @violations
     end
   end
 end

data/lib/yaml_bot/version.rb

@@ -1,3 +1,3 @@
 module YamlBot
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/new_spec.yml

@@ -0,0 +1,36 @@
+defaults:
+  required_key: false
+  types: ['String', 'List']
+rules:
+  - key: 'language'
+    required_key: true
+    types: ['String']
+    value_whitelist: ['android', 'go', 'python', 'ruby']
+  - key: 'env'
+    types: ['String', 'List', 'Object']
+  - key: 'env.global'
+  - key: 'env.matrix'
+  - key: 'before_install'
+  - key: 'install'
+  - key: 'before_script'
+  - key: 'script'
+  - key: 'branches.only'
+    types: ['List']
+  - key: 'branches.except'
+    types: ['List']
+  - key: 'jenkins.sudo'
+    types: ['Boolean', 'String']
+  - key: 'jenkins.use_gerrit'
+    types: ['Boolean', 'String']
+  - key: 'jenkins.collect.artifacts'
+
+  defaults:
+    <default values for rules>
+  rules:
+    - key: 'yaml address'
+      required_key: true|false
+      and_requires: ['list of yaml addresses']
+      or_requires: ['list of yaml addresses']
+      value_whitelist: ['list of values']
+      value_blacklist: ['list of values']
+      types: ['list of types']

data/yaml_bot.gemspec

@@ -24,7 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.46.0'
 
-  spec.add_runtime_dependency 'activesupport', '~> 5.0'
-
-  spec.required_ruby_version = '>=2.2'
+  spec.required_ruby_version = '>=2.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yaml_bot
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Luis Ortiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-15 00:00:00.000000000 Z
+date: 2017-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,20 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.46.0
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
 description: 
 email:
 - lortiz1145@gmail.com
@@ -100,19 +86,23 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
+- RULES_DEFINITION.md
 - Rakefile
 - _config.yml
 - bin/setup
 - bin/yamlbot
 - lib/yaml_bot.rb
 - lib/yaml_bot/cli_bot.rb
+- lib/yaml_bot/key_bot.rb
 - lib/yaml_bot/logging_bot.rb
-- lib/yaml_bot/resources/valid_accepted_types.yml
-- lib/yaml_bot/resources/valid_key_values.yml
+- lib/yaml_bot/parse_bot.rb
+- lib/yaml_bot/resources/valid_rules_keys.yml
+- lib/yaml_bot/resources/valid_types.yml
 - lib/yaml_bot/rules_bot.rb
 - lib/yaml_bot/validation_bot.rb
 - lib/yaml_bot/validation_error.rb
 - lib/yaml_bot/version.rb
+- new_spec.yml
 - yaml_bot.gemspec
 homepage: https://github.com/skippyPeanutButter/yaml_bot
 licenses:
@@ -126,7 +116,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -134,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Validate YAML files according to a set of rules.

data/lib/yaml_bot/resources/valid_accepted_types.yml

@@ -1,8 +0,0 @@
----
-- String
-- Fixnum
-- Array
-- Hash
-- TrueClass
-- FalseClass
-- Float

data/lib/yaml_bot/resources/valid_key_values.yml

@@ -1,3 +0,0 @@
----
-- accepted_types
-- subkeys