validate 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in validations.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kenneth Ballenegger
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,101 @@
+# Validations
+
+Validations is a validations library that can validate *any* object that can be
+converted to a hash using `to_hash`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'validations'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install validations
+
+## Usage
+
+This is what a validation looks like, with this library:
+
+```ruby
+# Here, we have a custom DSL for expressing validations. We put the
+# validations for the model in an extension which we require
+# independently. Doing `include Validations` in the module adds
+# the required method to make the DSL work, and adds a `validates`
+# method which will perform the validations are return whether they
+# pass, or whether there are any errors.
+
+module Store
+  
+  module ItemValidations
+    
+    # Order matters, first include library. Also: validations are
+    # executed and checked in the order in which they are defined.
+    include Validations
+    
+    # Validations are contained within a block, so as to not pollute
+    # the class namespace with a DSL's implementation.
+    validations do
+      
+      # simple ActiveRecord style validation
+      validates_presence_of :name
+      
+      # multiple keys can be included in one validation
+      validates_type_of :description, :long_description, is: String
+      
+      # or the key could be validated with a block
+      validates :type, with: -> { ['currency', 'iap'].include?(self) }
+      
+      # or we could build a validation for enums
+      validates_inclusion_of :reward_type, in: %w(currency consumable permanent)
+      
+      # inline `when`, validation only performed when block returns true
+      validates_numericality_of :amount, when: -> { type == :currency }
+      validates_type_of :currency, is: String, when: -> { type == :currency }
+      
+      # or alternatively `when` as a block
+      run_when -> { type == :currency } do
+        validates_numericality_of :amount
+        validates_type_of :currency, is: String
+      end
+      
+      # also, validates subdocuments
+      validates_child_hash :iap, when: -> { type == :iap } do
+        # the validation is now scoped to the subdocument,
+        # ie. we're validating the sub-doc
+        validates_type_of :id,      is: BSON::ObjectId
+        validates_type_of :iap_id,  is: String
+        validates_type_of :tier,    is: Numeric
+      end
+      
+      # arrays can be validated, too:
+      validates_array :tags do
+        # use regular validate function with the key self to
+        # validate array elements
+        validates_type_of :self, is: String
+      end
+      
+      # arrays of hashes can be validated by just adding regular
+      # validations inside the block
+      validates_array :logic do
+        validates_inclusion_of :type, in: [:one, :two]
+        validates_type_of :one, is: String, when: -> { type == :one }
+      end
+    end
+  end
+  ::Kongo::Model.add_extension(:store_items, ItemValidations)
+
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/validate/parser.rb

@@ -0,0 +1,65 @@
+
+module Validate
+
+  # The rules for parsing validations are such:
+  #
+  # - Validations are method calls (starting with the string `validates_`)
+  # - followed by field names as regular arguments (as symbols)
+  # - any options are included in an options hash, eg. is: String
+  # - and native blocks are reserved for children-validations
+  #
+  # For example:
+  #
+  #   validates_subhash :iap1, :iap2, when: -> { type == :iap } do
+  #     validates_type_of :id,   is: String
+  #     validates_type_of :tier, is: Numeric
+  #   end
+  #
+  class BlockParsingContext
+
+    def self.parse(&block)
+      # execute block, return array of validation methods called
+      context = BlockParsingContext.new
+      context.instance_exec(&block)
+      context.validations
+    end
+
+    def initialize
+      @validations = []
+    end
+
+    attr_reader :validations
+
+    def method_missing(method, *args, &block)
+      raise NoMethodError.new("No method #{method} to call in the context of a validation block.") unless method.to_s =~ /^validates/
+      raise NoMethodError.new("Undefined validation method: #{method}...") unless ValidationMethods.respond_to?(method)
+      opts = args.pop if args.last.is_a?(::Hash)
+      children = if block
+        BlockParsingContext.parse(&block)
+      end
+      @validations << {
+        name: method,
+        fields: args,
+        opts: opts,
+        validations: children
+      }
+    end
+
+    # `when` is a special case, its syntax is as follows:
+    #
+    #   when -> { ... } do
+    #     # validations go here
+    #   end
+    #
+    def run_when(condition, &block)
+      validations = BlockParsingContext.parse(&block)
+      validations.map do |v|
+        v[:opts] ||= {}
+        v[:opts][:when] = condition
+        v
+      end
+      @validations += validations
+    end
+  end
+end
+

data/lib/validate/validations.rb

@@ -0,0 +1,107 @@
+
+module Validate
+
+  # Every validation method has four arguments:
+  #
+  #   obj:        the `to_hash` of the object to validate
+  #   field:      the field to validate
+  #   opts:       the options for the validation
+  #   validator:  a Validator object that can be used for children
+  #
+  module ValidationMethods
+
+    # Validate a field by executing a block in the context of the field.
+    #
+    # `self` in the block is bound to the field's value, or `nil`.
+    #
+    #   validates :type, with: -> { is_a?(String) && self =~ /^a/ }
+    #
+    def self.validates(obj, field, opts, validator)
+      true == obj[field].instance_exec(&opts[:with])
+    end
+
+    # Validates that a field exists.
+    #
+    # `nil` is acceptable as a value for the field.
+    #
+    #   validates_presence_of :field
+    #
+    def self.validates_presence_of(obj, field, opts, validator)
+      obj.include?(field)
+    end
+
+    # Validates that a field exists and is an instance of a class or module.
+    #
+    #   validates_type_of :name, is: String
+    #
+    def self.validates_type_of(obj, field, opts, validator)
+      obj.include?(field) && obj[field].is_a?(opts[:is])
+    end
+
+    # Validates that the value of the field appears in an array.
+    #
+    #   validates_inclusion_of :type, in: %w(paid free)
+    #
+    def self.validates_inclusion_of(obj, field, opts, validator)
+      opts[:in].include?(obj[field])
+    end
+
+    # Validates that a field's value is numeric.
+    #
+    #   validates_numericality_of :amount
+    #
+    def self.validates_numericality_of(obj, field, opts, validator)
+      obj[field].is_a?(Numeric)
+    end
+
+    # Validates the value, ensure equality.
+    #
+    #   validates_value_of :field, is: 'something'
+    #
+    def self.validates_value_of(obj, field, opts, validator)
+      obj.include?(field) && obj[field] == opts[:is]
+    end
+
+    # Validates a Hash field with its own set of validations.
+    #
+    #   validates_child_hash :hash do
+    #     validates_value_of :type, is: 'price'
+    #     validates_numericality_of :amount
+    #   end
+    #
+    def self.validates_child_hash(obj, field, opts, validator)
+      return false unless obj[field].respond_to?(:to_hash)
+      hash = obj[field].to_hash
+      validator.validates?(hash)
+    end
+
+    # Validates each element in an Array with a set of validations.
+    #
+    # *Note:* the children validations should look at the field `:self` to
+    # contain the value to be validated. ie. it validates {self: element}
+    #
+    #   # ensures :elements is an array of strings
+    #   validates_array :elements do
+    #     validates_type_of :self, is: String
+    #   end
+    #
+    def self.validates_array(obj, field, opts, validator)
+      return false unless obj[field].respond_to?(:to_a)
+      array = obj[field].to_a
+      array.map do |e|
+        validator.validates?({self: e})
+      end.reduce {|a,b| a && b }
+    end
+
+    # Validates a field against a regular expression.
+    #
+    #  validates_regex :field, matches: /^hello/
+    #
+    def self.validates_regex(obj, field, opts, validator)
+      return false unless obj[field].respond_to?(:=~)
+      0 == (obj[field] =~ opts[:matches])
+    end
+
+  end
+
+end

data/lib/validate/validator.rb

@@ -0,0 +1,36 @@
+
+module Validate
+
+  # Actual implementation
+  #
+  class Validator
+
+    def initialize(validations)
+      @validations = validations
+    end
+
+    def validates?(context)
+      bool = @validations
+        .select do |v|
+          # `:when` is a special case, this gets processed right away and
+          # filtered out...
+          !(v[:opts] || {})[:when].is_a?(Proc) || context.instance_exec(&v[:opts][:when])
+        end
+        .map do |v|
+          # destructure fields
+          v[:fields].map {|f| v.merge(fields: f) }
+        end.flatten(1)
+        .map do |v|
+          # lastly, execute validation
+          validator = if v[:validations]
+            Validator.new(v[:validations])
+          end
+          ValidationMethods.send(v[:name], context.to_hash, v[:fields], v[:opts], validator)
+        end
+        .reduce {|a,b| a && b }
+        # return the result as a boolean
+      bool.nil? ? true : bool
+    end
+  end
+
+end

data/lib/validate/version.rb

@@ -0,0 +1,4 @@
+
+module Validate
+  VERSION = '1.0.0'
+end

data/lib/validate.rb

@@ -0,0 +1,30 @@
+require 'validate/version'
+require 'validate/validations'
+require 'validate/parser'
+require 'validate/validator'
+
+
+module Validate
+
+  module ClassMethods
+    # Doubles as setter & getter for @validations
+    # This method is also the main interface to this lib.
+    #
+    def validations(&block)
+      return @validator unless block
+      validations = BlockParsingContext.parse(&block)
+      @validator = Validator.new(validations)
+    end
+  end
+
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+
+  # May throw a nil NoMethodError if validations are not defined properly.
+  #
+  def validates?
+    self.class.validations.validates?(self)
+  end
+
+end

data/spec/validate_spec.rb

@@ -0,0 +1,445 @@
+
+require 'rspec'
+
+$: << File.dirname(__FILE__) + '/../lib'
+require 'validate'
+
+
+
+class BaseTestClass
+  def initialize(hash)
+    @hash = hash
+  end
+  def to_hash
+    @hash
+  end
+  include Validate
+end
+
+describe Validate do
+
+  context 'simple test' do
+
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates_presence_of 'name', when: -> { true }
+        end
+      end
+    end
+
+    it 'should validate a valid object' do
+      test = TestClass.new({"name" => :hello})
+      test.validates?.should == true
+    end
+
+    it 'should fail to validate an invalid object' do
+      test = TestClass.new({"not_name" => :hello})
+      test.validates?.should == false
+    end
+
+  end
+
+  context 'multiple fields' do
+
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates_presence_of :field1, :field2
+        end
+      end
+    end
+
+    it 'validate' do
+      test = TestClass.new(field1: true, field2: true)
+      test.validates?.should == true
+    end
+    
+    it 'fail' do
+      test = TestClass.new(field1: true)
+      test.validates?.should == false
+    end
+  end
+
+  context 'when option' do
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates_presence_of :name, when: -> { @hash[:something] == true }
+        end
+      end
+    end
+
+    it 'validates when when does not match' do
+      test = TestClass.new(something: false)
+      test.validates?.should == true
+    end
+    
+    it 'validates when when does match' do
+      test = TestClass.new(something: true, name: 'me')
+      test.validates?.should == true
+    end
+    
+    it 'fails' do
+      test = TestClass.new(something: true)
+      test.validates?.should == false
+    end
+  end
+
+  context 'run_when block' do
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          run_when -> { @hash[:something] == true } do
+            validates_presence_of :name
+            validates_numericality_of :amount
+          end
+        end
+      end
+    end
+
+    it 'validates when when does not match' do
+      test = TestClass.new(something: false)
+      test.validates?.should == true
+    end
+
+    it 'validates when when does match' do
+      test = TestClass.new(something: true, name: 'me', amount: 1.3)
+      test.validates?.should == true
+    end
+
+    it 'fails when one validations fail' do
+      test = TestClass.new(something: true, name: 'me')
+      test.validates?.should == false
+    end
+
+    it 'fails when all validations fail' do
+      test = TestClass.new(something: true)
+      test.validates?.should == false
+    end
+  end
+
+  context 'validates_presence_of' do
+    
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates_presence_of :field
+        end
+      end
+    end
+
+    it 'validates' do
+      test = TestClass.new(field: :something)
+      test.validates?.should == true
+    end
+
+    it 'fails' do
+      test = TestClass.new(random: :field_name)
+      test.validates?.should == false
+    end
+  end
+
+  context 'validates_type_of' do
+
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates_type_of :field, is: Symbol
+        end
+      end
+    end
+
+    it 'validates' do
+      test = TestClass.new(field: :symbol)
+      test.validates?.should == true
+    end
+    
+    it 'fails' do
+      test = TestClass.new(field: 'symbol')
+      test.validates?.should == false
+    end
+  end
+
+  context 'validates' do
+
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates :field, with: -> { self[:test] == :val }
+        end
+      end
+    end
+
+    it 'validates' do
+      test = TestClass.new(field: {test: :val})
+      test.validates?.should == true
+    end
+    
+    it 'fails' do
+      test = TestClass.new(field: {test: nil})
+      test.validates?.should == false
+    end
+  end
+
+  context 'validates_inclusion_of' do
+
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates_inclusion_of :field, in: %w(one two three)
+        end
+      end
+    end
+
+    it 'validates' do
+      test = TestClass.new(field: 'two')
+      test.validates?.should == true
+    end
+    
+    it 'fails' do
+      test = TestClass.new(field: {test: nil})
+      test.validates?.should == false
+    end
+  end
+
+  context 'validates_numericality_of' do
+
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates_numericality_of :field
+        end
+      end
+    end
+
+    it 'validates' do
+      test = TestClass.new(field: 1.3)
+      test.validates?.should == true
+    end
+    
+    it 'fails' do
+      test = TestClass.new(field: {test: nil})
+      test.validates?.should == false
+    end
+  end
+
+  context 'validates_value_of' do
+
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates_value_of :field, is: :something
+        end
+      end
+    end
+
+    it 'validates' do
+      test = TestClass.new(field: :something)
+      test.validates?.should == true
+    end
+    
+    it 'fails' do
+      test = TestClass.new(field: :something_else)
+      test.validates?.should == false
+    end
+  end
+
+  context 'validates_regex' do
+
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates_regex :field, matches: /^hello/
+        end
+      end
+    end
+
+    it 'validates' do
+      test = TestClass.new(field: 'hello world')
+      test.validates?.should == true
+    end
+    
+    it 'fails' do
+      test = TestClass.new(field: 'bye world')
+      test.validates?.should == false
+    end
+  end
+
+  context 'validates_child_hash' do
+
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates_child_hash :field do
+            validates_value_of :type, is: 'price'
+            validates_numericality_of :amount
+          end
+        end
+      end
+    end
+
+    it 'validates' do
+      test = TestClass.new(field: {type: 'price', amount: 1.3})
+      test.validates?.should == true
+    end
+    
+    it 'fails when not a hash' do
+      test = TestClass.new(field: nil)
+      test.validates?.should == false
+    end
+
+    it 'fails when all validations fail' do
+      test = TestClass.new(field: {random: :stuff})
+      test.validates?.should == false
+    end
+
+    it 'fails when only one validation fails' do
+      test = TestClass.new(field: {type: :random, amount: 20})
+      test.validates?.should == false
+    end
+  end
+
+
+  context 'validates_array' do
+
+    before do
+      class TestClass < BaseTestClass
+        validations do
+          validates_array :field do
+            validates_type_of :self, is: String
+          end
+        end
+      end
+    end
+
+    it 'validates' do
+      test = TestClass.new(field: %w(one two three))
+      test.validates?.should == true
+    end
+    
+    it 'fails when not a hash' do
+      test = TestClass.new(field: 'not an array')
+      test.validates?.should == false
+    end
+
+    it 'fails when all validations fail' do
+      test = TestClass.new(field: [1, 2, 3])
+      test.validates?.should == false
+    end
+
+    it 'fails when only one validation fails' do
+      test = TestClass.new(field: ['one', 'two', 3])
+      test.validates?.should == false
+    end
+  end
+
+
+  context 'complex example' do
+
+    before do
+
+      class TestClass < BaseTestClass
+
+        validations do
+          validates_type_of :id, is: Integer
+          validates_type_of :name, :description, is: String
+
+          validates_presence_of :secret
+
+          validates_inclusion_of :type, in: %w(paid free)
+
+          # validate a block in the data structure that must evaluate to true
+          validates :block, with: -> { self.call == true }
+
+          # number_or_symbols is an array that contains either numerics or
+          # symbols... only when it is set
+          validates_array :number_or_symbols, when: -> { @hash.include?(:number_or_symbols) } do
+
+            validates :self, with: -> { self.is_a?(String) || self.is_a?(Numeric) }
+
+            # when it is numeric, it must be greater than 0
+            validates :self,
+              when: -> { self[:self].is_a?(Numeric) },
+              with: -> { self > 0 }
+
+            # when it is a symbol, it start with `a` and is > 2 chars
+            run_when -> { self[:self].is_a?(String) } do
+              validates_regex :self, matches: /^a/
+              validates_regex :self, matches: /..+/
+            end
+          end
+
+          validates_child_hash :iap do
+            validates_type_of :id, is: Numeric
+            validates_type_of :bundle, is: String
+            validates_regex :bundle, matches: /(\w+\.){2}\w+/
+          end
+          validates :iap, with: -> { self.keys.count == 2 }
+        end
+      end
+
+      @valid_hash = {
+        id: 1,
+        name: 'item',
+        description: 'string',
+        secret: :anything,
+        type: 'paid',
+        block: -> { true },
+        number_or_symbols: [
+          1, 2, 3,
+          'awesome', 'awful'
+        ],
+        iap: {
+          id: 1,
+          bundle: 'com.chartboost.awesome'
+        }
+      }
+    end
+
+    it 'validates' do
+      test = TestClass.new(@valid_hash)
+      test.validates?.should == true
+    end
+
+    it 'fails when block is changed' do
+      hash = @valid_hash.dup
+      hash[:block] = -> { false }
+      test = TestClass.new(hash)
+      test.validates?.should == false
+    end
+
+    it 'fails when number_or_symbols contains invalid numbers' do
+      hash = @valid_hash.dup
+      hash[:number_or_symbols] = [0, -1, 'awesome']
+      test = TestClass.new(hash)
+      test.validates?.should == false
+    end
+
+    it 'fails when number_or_symbols contains invalid symbols' do
+      hash = @valid_hash.dup
+      hash[:number_or_symbols] = ['sick', 'awesome', 3, 'awful']
+      test = TestClass.new(hash)
+      test.validates?.should == false
+    end
+
+    it 'fails when secret does not exist' do
+      hash = @valid_hash.dup
+      hash.delete(:secret)
+      test = TestClass.new(hash)
+      test.validates?.should == false
+    end
+
+    it 'fails when number_or_symbols contains invalid numbers' do
+      hash = @valid_hash.dup
+      hash[:iap] = {
+        id: 1,
+        bundle: 'hello'
+      }
+      test = TestClass.new(hash)
+      test.validates?.should == false
+    end
+  end
+end
+
+

data/validate.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'validate/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'validate'
+  gem.version       = Validate::VERSION
+  gem.authors       = ['Kenneth Ballenegger']
+  gem.email         = ['kenneth@ballenegger.com']
+  gem.description   = %q{Validations is a library for validating data structures.}
+  gem.summary       = %q{Validations is a library for validating data structures.}
+  gem.homepage      = ''
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  # dependencies
+
+  gem.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: validate
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Kenneth Ballenegger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Validations is a library for validating data structures.
+email:
+- kenneth@ballenegger.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/validate.rb
+- lib/validate/parser.rb
+- lib/validate/validations.rb
+- lib/validate/validator.rb
+- lib/validate/version.rb
+- spec/validate_spec.rb
+- validate.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Validations is a library for validating data structures.
+test_files:
+- spec/validate_spec.rb
+has_rdoc: