subvalid 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19c0fec940d79b907b072f1df373e0b6add70f91
+  data.tar.gz: f2993841ad0edc5f065280f9518ed9e0df8d1a19
+SHA512:
+  metadata.gz: f41942e32113e9101e847c787e14fee98ec9b8a50baa6ddaba10d5e25b6ae73bf20b18d6df5fcdcdfae27cda032d24641d19f2452c9323fcbf5ec5e64f628c38
+  data.tar.gz: 4ecd389d43b363882c2378b89b649be4baf2e0dde5ff5df31812b13a8b28bd8b0a813462867df94ce2e2a80fb42d9c8b93c775bddec60cc7d9a59f83cb2aad81

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.2.2
+  - 2.1.6
+  - 2.0.0
+  - ruby-head
+  - jruby-9.0.0.0

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Envato
+
+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,88 @@
+# Subvalid
+
+Subvalid decouples your validation logic from your object structure. With
+Subvalid you can define different validation rules for different contexts. So
+rather than defining validation on the object, and having it be _"objective"_,
+you can define it in a separate class - so it's _"subjective"_. (as in **Sub**jective
+**valid**ation).
+
+Subvalid was extracted from a project at [Envato](http://envato.com) which
+required complex validation logic at each stage of the object's life cycle:
+- Users upload videos. The videos are validated to make sure an actual
+  video was uploaded (and not someone's university Powerpoint slides), that
+framerate is good, resolution and codec is acceptable etc. Failure here would
+reject the file straight away, and tell the user to try again with a new file.
+- Next we generate thumbnails, resized preview videos etc. If anything fails
+  validation here, it's a bug (wrong preview video size etc) - and we want to
+alert developers.
+- After the video is uploaded and processed, users would enter metadata: title,
+  description, tags etc. If that fails - we still want to save the item, but
+just leave it as _"incomplete"_, and allow the user to come back later and
+complete it. Once this passes, the item is ready, and we submit it for review to
+our internal review team.
+
+While
+[ActiveModel::Validations](http://api.rubyonrails.org/classes/ActiveModel/Validations.html)
+is great if you've got simple validation logic, it doesn't cut it for something
+complex like this. When you have different validation for the same object at
+each point in it's life cycle, you need something more flexible.
+
+ActiveModel also hooks in pretty deep into
+[ActiveRecord](http://guides.rubyonrails.org/active_record_validations.html).
+It's main use case assume you're just wanting to prevent bad data hitting your
+database - which isn't necessarily always the case.
+
+We needed something more. So Subvalid was born.
+
+And you can have the best of both worlds. Subvalid can exist alongside
+ActiveModel. ActiveModel::Validations is great for ensuring data consistency,
+and you can add it to your model classes as normal - and then write Subvalid
+validator classes in addition to handle more complex nuanced validation logic.
+Or do it all in Subvalid - up to you.
+
+## Features
+- Very simple, consistent API
+- Validation logic is defined in separate _"Validator"_ classes completely
+  decoupled from business logic
+- Multiple validators can be defined for each piece of data in your system to be
+  executed at different points
+- Caller is in control. No magic happening under the hood
+- Failing validation does not block saving to the database
+- Does not add _anything_ at all to business objects. No including modules, no
+  monkey patching, no object extension. Subvalid assumes POROs, but works with
+anything. A key design goal is to **not** pollute the objects being validated at
+all
+- Supports nested validation on nested object structures - and nicely handles
+  nested errors.
+
+## Development Status [![travis ci build](https://api.travis-ci.org/envato/subvalid.svg)](https://travis-ci.org/envato/subvalid)
+
+Subvalid is extracted from production code in use at Envato. However, it is undergoing early development, and APIs and features are almost certain to be in flux.
+
+## Getting Started
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'subvalid'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install subvalid
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/subvalid/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/lib/subvalid/validation_result.rb

@@ -0,0 +1,65 @@
+module Subvalid
+  class ValidationResult
+    attr_reader :errors, :children
+
+    def initialize
+      @errors = []
+      @children = {}
+    end
+
+    def valid?
+      errors.empty? && children.values.all?(&:valid?)
+    end
+
+    def add_error(error)
+      errors << error
+    end
+
+    def [](attribute)
+      children[attribute]
+    end
+
+    def merge_child!(attribute, result)
+      child = children[attribute]
+      if child
+        child.merge!(result)
+      else
+        children[attribute] = result
+      end
+    end
+
+    def to_h
+      hash = {}
+      hash[:errors] = errors.dup unless errors.empty?
+      children.each do |attribute, child|
+        hash[attribute] = child.to_h unless child.valid?
+      end
+      hash
+    end
+
+    def flatten(parent_attributes=[])
+      # TODO make this more flexible than just hardcoded format
+      flat_errors = errors.map{|error|
+        if parent_attributes.empty?
+          error
+        else
+          human_keys = parent_attributes.map{|a| a.to_s.gsub('_', ' ')}
+          [human_keys.join(", "), error].join(": ")
+        end
+      }
+      children.each do |attribute, child|
+        flat_errors += child.flatten(parent_attributes + [attribute])
+      end
+      flat_errors
+    end
+
+    protected
+    def merge!(result)
+      @errors += result.errors
+      children.merge!(result.children){|key, old_child, new_child|
+        old_child.merge!(new_child)
+        old_child
+      }
+    end
+  end
+end

data/lib/subvalid/validator.rb

@@ -0,0 +1,81 @@
+module Subvalid
+  module Validator
+    def self.included(base)
+      base.class_eval do
+        extend DSL
+      end
+      base.extend API
+    end
+
+    module DSL
+
+      def validates(*attributes, **validators, &block)
+        if validators.empty? && !block
+          raise "no validations or block specified"
+        end
+
+        attributes = [:base] if attributes.empty?
+
+        add_validations(attributes, validators, block)
+      end
+
+      private
+      ValidatorEntry = Struct.new(:validator, :args)
+      def validations
+        @validations ||= Hash.new{|vals,attribute| vals[attribute] = [] }
+      end
+
+      def add_validations(attributes, validators, block)
+        attributes.each do |attribute|
+          validators.each do |validator_key, args|
+            validator = ValidatorRegistry[validator_key]
+            validations[attribute] << ValidatorEntry.new(validator, args)
+          end
+          validations[attribute] << ValidatorEntry.new(BlockValidator, block) if block
+        end
+      end
+    end
+
+    module API
+      def validate(object, validation_result=ValidationResult.new, *args)
+        validations.each do |attribute, validators|
+          attribute_result = if attribute == :base
+                               validation_result
+                             else
+                               ValidationResult.new
+                             end
+
+          validators.each do |validator_entry|
+            validator = validator_entry.validator
+            if attribute == :base
+              validator.validate(object, attribute_result, *validator_entry.args)
+            elsif object
+              validator.validate(object.send(attribute), attribute_result, *validator_entry.args)
+            else
+              # no-op if we 're asked to validate an attribute for a nil value - that needs to be caught by a user defined `presence` validation instead
+            end
+          end
+
+          validation_result.merge_child!(attribute, attribute_result) unless attribute == :base
+        end
+        validation_result
+      end
+    end
+
+    class BlockValidator
+      class Context
+        include Subvalid::Validator::DSL
+        include Subvalid::Validator::API
+      end
+
+      def self.validate(object, validation_result=ValidationResult.new, *args)
+        #return unless object # don't pass nil object into block - this should be handled with a PresenceValidator if it needs to be flagged as a validation error
+        block = args[0]
+
+        context = Context.new
+        context.instance_exec(&block)
+        context.validate(object, validation_result, args)
+      end
+    end
+  end
+end

data/lib/subvalid/validator_registry.rb

@@ -0,0 +1,18 @@
+module Subvalid
+  class ValidatorRegistry
+    class << self
+      def [](key)
+        validators[key] or raise "no validator with key=#{key}"
+      end
+
+      def register(key, validator)
+        validators[key] = validator
+      end
+
+      private
+      def validators
+        @validators ||= {}
+      end
+    end
+  end
+end

data/lib/subvalid/validators/format_validator.rb

@@ -0,0 +1,22 @@
+module Subvalid
+  module Validators
+    class FormatValidator
+      def self.validate(object, validation_result=ValidationResult.new, *args)
+        options = args.to_h rescue args
+        with = nil
+        message = "is invalid"
+        case options
+        when Regexp
+          with = options
+        when Hash
+          with = options.fetch(:with)
+          message = options[:message] || message
+        else
+          raise "don't know what to do with #{options}"
+        end
+        validation_result.add_error(message) unless with.match(object)
+      end
+    end
+    ValidatorRegistry.register(:format, FormatValidator)
+  end
+end

data/lib/subvalid/validators/in_validator.rb

@@ -0,0 +1,22 @@
+module Subvalid
+  module Validators
+    class InValidator
+      def self.validate(object, validation_result=ValidationResult.new, *args)
+        options = args.to_h rescue args
+        within = nil
+        message = "is not included in the list"
+        case options
+        when Hash
+          within = options.fetch(:within)
+          message = options[:message] || message
+        when Array
+          within = options
+        else
+          raise "don't know what to do with #{options}"
+        end
+        validation_result.add_error(message) unless within.include?(object)
+      end
+    end
+    ValidatorRegistry.register(:in, InValidator)
+  end
+end

data/lib/subvalid/validators/length_validator.rb

@@ -0,0 +1,20 @@
+module Subvalid
+  module Validators
+    class LengthValidator
+      def self.validate(object, validation_result=ValidationResult.new, *args)
+        return unless object
+        args = args.to_h
+        args.each do |operator, value|
+          case operator
+          when :maximum
+            validation_result.add_error("is too long, maximum is #{value}") if object.size > value
+            # TODO ALL the other operators from http://guides.rubyonrails.org/active_record_validations.html#length
+          else
+            raise "don't know what to do with operator=#{operator}"
+          end
+        end
+      end
+    end
+    ValidatorRegistry.register(:length, LengthValidator)
+  end
+end

data/lib/subvalid/validators/numericality_validator.rb

@@ -0,0 +1,19 @@
+module Subvalid
+  module Validators
+    class NumericalityValidator
+      def self.validate(object, validation_result=ValidationResult.new, *args)
+        args = args.to_h
+        args.each do |operator, value|
+          case operator
+            when :greater_than_or_equal_to
+              validation_result.add_error("must be greater than or equal to #{value}" ) unless object >= value
+            # TODO ALL the other operators from http://guides.rubyonrails.org/active_record_validations.html#numericality
+            else
+              raise "don't know what to do with operator=#{operator}"
+          end
+        end
+      end
+    end
+    ValidatorRegistry.register(:numericality, NumericalityValidator)
+  end
+end

data/lib/subvalid/validators/presence_validator.rb

@@ -0,0 +1,18 @@
+module Subvalid
+  module Validators
+    class PresenceValidator
+      def self.validate(object, validation_result=ValidationResult.new, *args)
+        present = if object
+                    if object.respond_to?(:present?)
+                      object.present?
+                    else
+                      object
+                    end
+                  end
+
+        validation_result.add_error("is not present") unless present
+      end
+    end
+    ValidatorRegistry.register(:presence, PresenceValidator)
+  end
+end

data/lib/subvalid/validators/with_validator.rb

@@ -0,0 +1,17 @@
+module Subvalid
+  module Validators
+    class WithValidator
+      def self.validate(object, validation_result=ValidationResult.new, *args)
+        case args[0]
+        when Class
+          klass = args[0]
+          klass.validate(object, validation_result)
+        when Proc
+          prok = args[0]
+          prok.(object, validation_result)
+        end
+      end
+    end
+    ValidatorRegistry.register(:with, WithValidator)
+  end
+end

data/lib/subvalid/validators.rb

@@ -0,0 +1,10 @@
+require "subvalid/validators/format_validator"
+require "subvalid/validators/in_validator"
+require "subvalid/validators/length_validator"
+require "subvalid/validators/numericality_validator"
+require "subvalid/validators/presence_validator"
+require "subvalid/validators/with_validator"
+module Subvalid
+  module Validators
+  end
+end

data/lib/subvalid/version.rb

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

data/lib/subvalid.rb

@@ -0,0 +1,8 @@
+require "subvalid/version"
+require "subvalid/validation_result"
+require "subvalid/validator"
+require "subvalid/validator_registry"
+require "subvalid/validators"
+
+module Subvalid
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "subvalid"

data/spec/subvalid/validation_result_spec.rb

@@ -0,0 +1,159 @@
+require "spec_helper"
+
+describe Subvalid::ValidationResult do
+  describe "#valid?" do
+    context "when there are no errors" do
+      context "when children have no errors" do
+        before do
+          child = Subvalid::ValidationResult.new
+          subject.children[:foo] = child
+        end
+        it { is_expected.to be_valid }
+      end
+
+      context "when children have errors" do
+        before do
+          child = Subvalid::ValidationResult.new
+          child.add_error("this is an error")
+          subject.children[:foo] = child
+        end
+        it { is_expected.to_not be_valid }
+      end
+    end
+
+    context "when there are errors" do
+      before do
+        subject.add_error("this is an error")
+      end
+      it { is_expected.to_not be_valid }
+    end
+  end
+
+  describe "#add_error" do
+    it "adds the error" do
+      subject.add_error("duh")
+      subject.add_error("doh")
+      expect(subject.errors).to eq(["duh", "doh"])
+    end
+  end
+
+  describe "#[]" do
+    context "when child attribute exists" do
+      let(:child) { Subvalid::ValidationResult.new }
+      before do
+        subject.children[:foo] = child
+      end
+      it "returns the child validation result" do
+        expect(subject[:foo]).to be(child)
+      end
+    end
+
+    context "when child attribute does not exist" do
+      it "returns nil" do
+        expect(subject[:blah]).to be_nil
+      end
+    end
+  end
+
+  describe "merge_child!" do
+    context "when child attribute already exists" do
+      let(:child1) {
+        result = Subvalid::ValidationResult.new
+        result.add_error("Insufficient cheese")
+        grandchild = Subvalid::ValidationResult.new
+        grandchild.add_error("not tasty")
+        result.merge_child!(:tastiness, grandchild)
+        grandchild2 = Subvalid::ValidationResult.new
+        grandchild2.add_error("it's not OK")
+        result.merge_child!(:ok, grandchild2)
+        result
+      }
+      let(:child2) {
+        result = Subvalid::ValidationResult.new
+        result.add_error("blue cheese is awful")
+        grandchild = Subvalid::ValidationResult.new
+        grandchild.add_error("more smelly than tasty")
+        result.merge_child!(:tastiness, grandchild)
+        result
+      }
+      it "merges results together recursively" do
+        subject.merge_child!(:cheese, child1)
+        subject.merge_child!(:cheese, child2)
+        expect(subject[:cheese].errors).to eq(["Insufficient cheese", "blue cheese is awful"])
+        expect(subject[:cheese][:tastiness].errors).to eq(["not tasty", "more smelly than tasty"])
+        expect(subject[:cheese][:ok].errors).to eq(["it's not OK"])
+      end
+    end
+
+    context "when child attribute doesn't exist" do
+      let(:child) {
+        result = Subvalid::ValidationResult.new
+        result.add_error("Insufficient cheese")
+        result
+      }
+      it "sets the child result from the passed in result" do
+        subject.merge_child!(:cheese, child)
+        expect(subject[:cheese].errors).to eq(["Insufficient cheese"])
+      end
+    end
+  end
+
+  describe "#to_h" do
+    before do
+      child = Subvalid::ValidationResult.new
+      child.add_error("this is an error")
+      grandchild1 = Subvalid::ValidationResult.new
+      grandchild1.add_error("this is another error")
+      grandchild2 = Subvalid::ValidationResult.new # no errors
+      child.children[:bar] = grandchild1
+      child.children[:baz] = grandchild2
+      subject.children[:foo] = child
+      subject.add_error("this is a base error")
+    end
+
+    it "generates a hash of attributes with errors" do
+      expect(subject.to_h).to eq({
+        errors: ["this is a base error"],
+        foo: {
+          errors: ["this is an error"],
+          bar: {
+            errors: ["this is another error"]
+          }
+        }
+      })
+    end
+
+    it "has errors on attribute itself in special :errors key" do
+      hash = subject.to_h
+      expect(hash[:errors]).to eq(["this is a base error"])
+      expect(hash[:foo][:errors]).to eq(["this is an error"])
+      expect(hash[:foo][:bar][:errors]).to eq(["this is another error"])
+    end
+
+    it "doesn't include anything for attributes that are valid" do
+      expect(subject.to_h[:foo]).to_not have_key(:baz)
+    end
+  end
+
+  describe "#flatten" do
+    before do
+      child = Subvalid::ValidationResult.new
+      child.add_error("this is an error")
+      grandchild1 = Subvalid::ValidationResult.new
+      grandchild1.add_error("this is another error")
+      grandchild2 = Subvalid::ValidationResult.new # no errors
+      child.children[:bar] = grandchild1
+      child.children[:baz] = grandchild2
+      subject.children[:foo] = child
+      subject.add_error("this is a base error")
+    end
+
+    it "generates flat list of error messages recursively" do
+      expect(subject.flatten).to eq([
+        "this is a base error",
+        "foo: this is an error",
+        "foo, bar: this is another error"
+      ])
+    end
+  end
+end

data/spec/subvalid/validator_registry_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Subvalid::ValidatorRegistry do
+  describe "#[]" do
+    before do
+      described_class.register(:accessor_test, "a validator")
+    end
+    context "when validator with key is registered" do
+      it "returns the validator" do
+        expect(described_class[:accessor_test]).to eq("a validator")
+      end
+    end
+
+    context "when validator doesn't exist" do
+      it "raises an error" do
+        expect { described_class[:bad_key] }.to raise_error
+      end
+    end
+  end
+
+  describe "#register" do
+    it "add the validator with the key" do
+      # yes, this is a duplicat of the #[] spec, but it demonstrates the publicly API, so we'll have it
+      described_class.register(:register_test, "registered validator")
+      expect(described_class[:register_test]).to eq("registered validator")
+    end
+  end
+end

data/spec/subvalid/validator_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe Subvalid::Validator do
+  let(:stub_validator) {
+    -> (object, result) { "testing #{object} " }
+  }
+  class FooValidator
+    include Subvalid::Validator
+
+    STUB_VALIDATOR = -> (object, result) { result.add_error("testing #{object}") }
+
+
+    validates with: STUB_VALIDATOR
+    validates :foo, with: STUB_VALIDATOR
+    validates :child do
+      validates :boz, with: STUB_VALIDATOR
+    end
+  end
+
+  class TestValidator
+    def self.validate(object, validation_result=ValidationResult.new, *args)
+      validation_result.add_error("testing #{object}")
+    end
+  end
+  Subvalid::ValidatorRegistry.register(:test, TestValidator)
+
+  Poro = Struct.new(:foo, :bar, :child) do
+    def to_s
+      "I'M A PORO"
+    end
+  end
+
+  PoroChild = Struct.new(:baz, :boz) do
+    def to_s
+      "I'M A PORO CHILD"
+    end
+  end
+
+  let(:poro) { Poro.new("foo", "bar", 
+                        PoroChild.new("baz", "boz")) }
+
+  describe "#validate" do
+    subject { FooValidator.validate(poro) }
+    it "returns a validation result" do
+      expect(subject).to be_a(Subvalid::ValidationResult)
+    end
+
+    it "validates base object" do
+      expect(subject.errors).to eq(["testing I'M A PORO"])
+    end
+
+    it "validates attribute on object" do
+      expect(subject[:foo].errors).to eq(["testing foo"])
+    end
+
+    it "validates child" do
+      expect(subject[:child][:boz].errors).to eq(["testing boz"])
+    end
+  end
+
+end

data/spec/subvalid_spec.rb

@@ -0,0 +1,4 @@
+require "spec_helper"
+
+describe Subvalid do
+end

data/subvalid.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "subvalid/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "subvalid"
+  spec.version       = Subvalid::VERSION
+  spec.authors       = ["Julian Doherty"]
+  spec.email         = ["madlep@madlep.com"]
+  spec.summary       = %q{Subjective validation for Plain Old Ruby Objects}
+  spec.description   = %q{Subvalid allows you to use a familiar syntax to define validator classes to validate plain objects. Rather than hard coding single validation logic into the objects themselves, different validation logic can be used depending on the context.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: subvalid
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Julian Doherty
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: pry
+  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'
+description: Subvalid allows you to use a familiar syntax to define validator classes
+  to validate plain objects. Rather than hard coding single validation logic into
+  the objects themselves, different validation logic can be used depending on the
+  context.
+email:
+- madlep@madlep.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/subvalid.rb
+- lib/subvalid/validation_result.rb
+- lib/subvalid/validator.rb
+- lib/subvalid/validator_registry.rb
+- lib/subvalid/validators.rb
+- lib/subvalid/validators/format_validator.rb
+- lib/subvalid/validators/in_validator.rb
+- lib/subvalid/validators/length_validator.rb
+- lib/subvalid/validators/numericality_validator.rb
+- lib/subvalid/validators/presence_validator.rb
+- lib/subvalid/validators/with_validator.rb
+- lib/subvalid/version.rb
+- spec/spec_helper.rb
+- spec/subvalid/validation_result_spec.rb
+- spec/subvalid/validator_registry_spec.rb
+- spec/subvalid/validator_spec.rb
+- spec/subvalid_spec.rb
+- subvalid.gemspec
+homepage: ''
+licenses:
+- MIT
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Subjective validation for Plain Old Ruby Objects
+test_files:
+- spec/spec_helper.rb
+- spec/subvalid/validation_result_spec.rb
+- spec/subvalid/validator_registry_spec.rb
+- spec/subvalid/validator_spec.rb
+- spec/subvalid_spec.rb