active_conformity 0.2.13

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 04c7e1d71487e2d58faf2cbf582e10386f4b1018
+  data.tar.gz: 5f5a5e28dae4bb907dcf8644bb9de7c3157c15b4
+SHA512:
+  metadata.gz: 5fd79e607d2317bc41ad6c9f2b46653e6ff54cf345742db1e3a9d9934d0552848230fd205998928d02bed98fddb86383ae16ee2e68f76a671f04442525ae1095
+  data.tar.gz: e50e71111dc5c00dc907e09af1688574367ce5f433eb61323a007a283844f215014bc8291af887b3af9804c61c4fa1bb47a53c7325d0a5cb3a21a375175701c2

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/spec/*.log

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--fail-fast

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_conformity.gemspec
+gemspec
+
+group :test do
+  gem 'rails'
+  gem 'byebug'
+  gem 'rspec'
+  gem 'rspec-rails', '~> 3.1.0'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Daniel Miller
+
+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,121 @@
+# ActiveConformity
+[![Code Climate](https://codeclimate.com/github/dandlezzz/active_conformity/badges/gpa.svg)](https://codeclimate.com/github/dandlezzz/active_conformity)
+
+Your favorite rails validations driven not by code but by your data.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_conformity'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_conformity
+
+## Usage
+
+ActiveConformity comes with a helpful install generator.
+
+	$ rails g active_conformity:install
+
+ This will generate a migration for you that creates the conformables table. The table responsible for storing all of the validation data. Additionally, it will create a module in your lib file where you can write custom validation methods.
+
+
+ ActiveConformity is for use when validating if objects are of a specific composition.
+ For example, lets say you have the following model structure:
+
+ ```
+ class Car
+ 	has_one :engine
+ 	#attrs :size
+ end
+
+ class Engine
+ 	belongs_to :car
+ end
+ ```
+
+In this example you have a database full of different engines. Each car model has a link to these things. If you want ensure that the diesel engine is on a car of a size 2000 you have a couple of options.
+
+```
+class Car
+	has_one :engine
+    validate :proper_engine
+
+    def proper_engine
+    	return true if size >= 2000 && engine.name == "diesel"
+        errors.add("car is too small for diesel engine")
+    end
+end
+
+```
+
+This works but can become very complex if you have lots of engines and even more complicated conditions. ActiveConformity provides a way to add these conditions to your database, as json.
+
+```
+diesel_engine = Engine.find_by(name: "diesel")
+diesel_engine.add_conformity_set!( {size: {:numericality => { :greater_than => 2000} } }, conformist_type: "Car")
+
+car1 = Car.create!(size: 2000, engine: diesel_engine)
+car1.conforms? # true
+car2 = Car.create!(size: 1000, engine: diesel_engine)
+car2.conforms? # false
+car2.conformity_errors # [{size: "car is too small for diesel engine"}]
+
+```
+
+The add_conformity_set! method saves the json to your database any time  a car has a diesel engine, calling .conforms? will check the car's size to ensure it can accomodate the diesel engine.
+
+##
+
+Please note, lack of conformity does not prevent persistence as it does with .valid? in Rails. It is suggested that you implement this in a callback on the model.
+
+##
+
+ActiveConformity refers to the objects that tell other objects what do as conformables and the objects that are being told what to do as conformists. In the example above, the car is the conformist and the engine is the conformable.
+
+There are several methods available to inspect what makes an object on conform. In the previous example if you want to see all of the rules the car most conform to you can do the following.
+
+```
+car1.aggregate_conformity_set # {size: {:numericality => { :greater_than => 2000} } }
+```
+
+This shows all of the validations that the model will have to run through when .conforms? is called.
+
+##
+
+In order to debug conformity errors, ActiveConformity provides several methods to query the database in order to get a better understanding of why the object conforms or does not.
+
+```
+car1.conformable_references #returns [diesel_engine]
+```
+The conformable references returns a list of all the objects that the car gets a conformity set from. Additionally, for even more fine grained debugging you can call
+```
+car1.conformity_sets_by_reference # {"Engine id: 1" =>{size: {:numericality => { :greater_than => 2000} } } }
+```
+This returns a complex hash that shows the id of all of the objects mapped to their individual conformity_set.
+
+##
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/active_conformity/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,3 @@
+require "bundler/gem_tasks"
+
+FileList['tasks/**/*.rake'].each { |task| import task }

data/active_conformity.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_conformity/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_conformity"
+  spec.version       = ActiveConformity::VERSION
+  spec.authors       = ["dandlezzz"]
+  spec.email         = ["danm@workwithopal.com"]
+
+
+  spec.summary       = "Database driven validations."
+  spec.description   = "Store Rails validations as JSON to serve via api and drive complex validation logic."
+  spec.homepage      = "http://www.github.com/dandlezzz/active_conformity"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "active_conformity"
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/active_conformity/conformable.rb

@@ -0,0 +1,34 @@
+require 'active_conformity/conformity_set_validator'
+module ActiveConformity
+  class Conformable < ActiveRecord::Base
+    validates :conformity_set, conformity_set: true
+
+    def add_conformity_set(incoming_set={})
+      self.conformity_set = JSON.parse(self.conformity_set) if self.conformity_set.is_a?(String)
+      conformity_set = JSON.parse(incoming_set) rescue incoming_set
+      conformity_set = self.conformity_set.deep_merge(incoming_set) rescue conformity_set
+      self.conformity_set = conformity_set.to_json
+    end
+
+    def conformity_set
+      if super.is_a? String
+        JSON.parse(super).deep_symbolize_keys! rescue super
+      else
+        super
+      end
+    end
+
+    def remove_coformity_rule(attr)
+      conformity_set = JSON.parse(self.conformity_set) rescue self.conformity_set
+      conformity_set.delete(attr) do
+        raise "no rule found for #{attr.to_s}"
+      end
+      self.conformity_set = conformity_set.to_json
+    end
+
+    def remove_coformity_rule!(attr)
+      remove_coformity_rule(attr)
+      save!
+    end
+  end
+end

data/lib/active_conformity/conformable_extensions.rb

@@ -0,0 +1,116 @@
+require 'active_support/concern'
+module ActiveConformity
+  module ConformableExtensions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      @dependents = []
+
+      def dependents
+        @dependents
+      end
+
+      def conforming_dependents(*dependents)
+        dependents.each do |d|
+          if !self.reflect_on_all_associations.map(&:name).include?(d)
+            raise "NOT A VALID DEPENDENT, MUST BE ONE OF THE MODEL'S ASSOCIATIONS!"
+          end
+        end
+        @dependents = dependents
+      end
+    end
+
+    def conforms?
+      validator.conforms? && conforming_dependents_conform?
+    end
+
+    def conformity_errors
+      validator.errors.messages
+    end
+
+    def aggregate_conformity_set
+      acs = {}
+      return acs if !conformable_references.any? #need to think about this a little more
+      conformable_references.each do |c|
+        # This could be more efficient with some advanced sql techniques
+        # Also need indexes on these
+        c = Conformable.find_by!(conformable_id: c.id, conformable_type: c.class.name).conformity_set
+        c = JSON.parse(c) if c.is_a?(String)
+        acs.merge!(c)
+      end
+      acs
+    end
+
+    def conforming_dependents_conform?
+      return true if dependents.blank?
+      !dependents.flat_map { |da| self.send(da)}
+      .any?{ |da| !da.conforms? }
+    end
+
+    def conformity_sets_by_reference
+      conformable_references.flat_map do |cr|
+        {"#{cr.class.name} id: #{cr.id}"=> cr.conformable.conformity_set}
+      end
+    end
+
+    def conformable
+      @conformable ||= Conformable.find_by(conformable_id: self.id, conformable_type: self.class.name)
+      @conformable
+    end
+
+    def add_conformity_set!(conformity_set = {}, conformist_type)
+      conformable_attrs = {conformable_id: self.id, conformable_type: self.class.name, conformist_type: conformist_type}
+      @conformable = Conformable.where(conformable_attrs).first_or_create
+      @conformable.add_conformity_set(conformity_set)
+      @conformable.save!
+    end
+
+    def conformable_references
+      [conformable_references_from_associations + add_self_to_conformable_references.to_a]
+      .flatten.compact.uniq
+    end
+
+    private
+
+    def dependents
+      self.class.dependents
+    end
+
+    def method_missing(m, *args, &block)
+      if m.to_sym == :conformity_set && !self.class.column_names.include?(m.to_s)
+        conformable.try(:conformity_set)
+      else
+        super
+      end
+    end
+
+    def validator
+      ActiveConformity::ObjectValidator.new(self, aggregate_conformity_set)
+    end
+
+    def conformable_references_from_associations
+      self.class.reflect_on_all_associations.flat_map do |assoc|
+        self.send(assoc.name) if conformable_types.include?(assoc.klass.name) rescue nil
+      end
+    end
+
+    def add_self_to_conformable_references
+      [self] if Conformable.where(conformable_id: self.id,
+      conformable_type: self.class.name).any?
+    end
+
+    def conformable_types
+      return @conformable_types if defined?(@conformable_types)
+      @conformable_types = conformables_for_class.pluck(:conformable_type)
+      @conformable_types
+    end
+
+    def conformables_for_class
+      return @conformables_for_class if defined?(@conformables_for_class)
+      @conformables_for_class = Conformable.where(conformist_type: self.class.name)
+      @conformables_for_class
+    end
+  end
+end
+
+ActiveRecord::Base.include ActiveConformity::ConformableExtensions

data/lib/active_conformity/conformity_set_validator.rb

@@ -0,0 +1,81 @@
+require 'active_model'
+
+class ConformitySetValidator < ActiveModel::EachValidator
+  include ::ActiveConformity::Reifiers
+
+  attr_accessor :conformable
+
+  def validate_each(conformable, conformity_set, conformity_set_value)
+    @conformable = conformable
+    return add_errors("Conformity set required!") if conformity_set_value.nil?
+    begin
+      if conformity_set_value.is_a? String
+        conformity_set_value = JSON.parse(conformity_set_value)
+      end
+    rescue
+      return add_errors "#{conformity_set_value} cannot be parsed to a hash!"
+    end
+    conformity_set_value.each do |attribute, value|
+      return validate_custom_method(value) if attribute.to_sym == :method
+      validate_attr_based_validations(attribute, value)
+    end
+  end
+
+  private
+
+  def validate_attr_based_validations(attribute, value)
+    is_a_conformists_attribute?(attribute)
+    value.each do |rule, constraint|
+      validation_rule_conforms?(attribute, rule, constraint)
+    end
+  end
+
+  def custom_method_is_defined?(method_name)
+    ActiveConformityCustomMethods.public_instance_methods.include?(method_name.to_sym)
+  end
+
+  def custom_method_error(method_name)
+    add_errors("#{method_name} is not defined in ActiveConformityCustomMethods!")
+  end
+
+  def validate_custom_method(method_name)
+    return true
+    # custom_method_error(method_name) if !custom_method_is_defined?(method_name) # need a better solution here
+  end
+
+  def validation_rule_conforms?(attribute, rule, constraint)
+    attribute = attribute.to_sym if attribute.is_a?(String)
+    rule = rule.to_sym if rule.is_a?(String)
+    constraint.symbolize_keys! if constraint.is_a?(Hash)
+    begin
+      @conformable.conformist_type.constantize.dup.validates(attribute, reify_regex({rule => constraint}))
+    rescue ArgumentError => e
+      add_errors(e.to_s)
+      false
+    end
+    true
+  end
+
+  #conformity set by conformable
+
+  def is_a_conformists_attribute?(str)
+    str = str.to_s
+    if !conformists_attributes.include?(str)
+        return add_errors("#{str} is not an attribute of #{conformable.conformist_type.to_s}!")
+    end
+    return true
+  end
+
+  def conformists_attributes
+    if !conformable.conformist_type.constantize.respond_to?(:column_names)
+      raise "#{conformable.conformist_type} is not a valid conformist, must be an ActiveRecord Model"
+    else
+      conformable.conformist_type.constantize.column_names
+    end
+  end
+
+  def add_errors(msg)
+    @conformable.errors.add(:conformity_set, msg)
+    return false
+  end
+end

data/lib/active_conformity/object_validator.rb

@@ -0,0 +1,99 @@
+require 'active_model/validations'
+begin
+  require 'active_conformity_custom_methods'
+rescue LoadError
+  #lets the user load their own custom methods
+end
+module ActiveConformity
+  class DynamicValidator
+    include ActiveModel::Validations
+    include ::ActiveConformityCustomMethods rescue false# complicated here
+
+    attr_reader :obj
+    attr_accessor :method_args
+
+    def initialize(obj)
+      @obj = obj
+      @method_args = {}
+      set_accessors
+    end
+
+    private
+
+    def set_accessors
+      obj.attributes.each do |k,v|
+        self.class_eval do
+          attr_accessor k.to_sym
+        end
+        instance_variable_set("@#{k}", v)
+      end
+    end
+  end
+
+  class ObjectValidator
+    include ActiveConformity::Reifiers
+
+    attr_accessor :conformity_set, :errors, :obj,
+                  :validator_klass, :conforms, :validator
+
+
+    def initialize(obj, conformity_set)
+      @obj = obj
+      @conformity_set = ::HashWithIndifferentAccess.new(conformity_set)
+      @errors = {}
+      create_validator_klass
+    end
+
+    def conforms?
+      @conforms = true if @conformity_set.blank?
+      check_conformity
+      remove_dynamic_validator
+      @conforms
+    end
+
+    def errors
+      check_conformity
+      remove_dynamic_validator
+      @errors
+    end
+
+    private
+
+    def remove_dynamic_validator
+      Object.send(:remove_const, @validator_klass.name.to_sym)
+    end
+
+    def create_validator_klass
+      validator_klass_name = (0...50).map { ('A'..'Z').to_a[rand(26)] }.join
+      @validator_klass = Object.const_set(validator_klass_name, Class.new(DynamicValidator))
+    end
+
+    def check_conformity
+      @validator = @validator_klass.new(@obj)
+      @conformity_set.each do |attr,rule|
+        call_validation_method(attr, rule)
+      end
+      @conforms = @validator.valid?
+      @errors = @validator.errors
+    end
+
+    def call_validation_method(attr, rule)
+      if attr.to_sym == :method
+        if rule.is_a?(String)
+          rule_name = rule.to_sym
+        elsif rule.is_a?(Hash)
+          rule_name = rule[:name].to_sym
+          set_custom_method_arguments(rule[:arguments])
+        end
+
+        @validator_klass.validate rule_name
+      else
+        @validator_klass.validates attr, reify_rule(rule)
+      end
+    end
+
+    def set_custom_method_arguments(args_hash)
+      args_hash.each{ |k,v| @validator.method_args[k] = v }
+    end
+  end
+end

data/lib/active_conformity/reifiers.rb

@@ -0,0 +1,19 @@
+
+module ActiveConformity
+  module Reifiers
+
+    def reify_rule(rule)
+      reify_regex(rule).deep_symbolize_keys
+    end
+
+    def reify_regex(rule)
+      return rule unless rule.is_a?(Hash)
+      if rule["format"]
+        rule["format"]["with"] = Regexp.new(rule["format"]["with"])
+      elsif rule[:format]
+        rule[:format][:with] = Regexp.new(rule[:format][:with])
+      end
+      return rule
+    end
+  end
+end

data/lib/active_conformity/version.rb

@@ -0,0 +1,3 @@
+module ActiveConformity
+  VERSION = "0.2.13"
+end

data/lib/active_conformity.rb

@@ -0,0 +1,9 @@
+require "active_conformity/version"
+require "active_conformity/reifiers"
+require "active_conformity/object_validator"
+require "active_conformity/conformable"
+require "active_conformity/conformity_set_validator"
+require "active_conformity/conformable_extensions"
+
+
+module ActiveConformity; end

data/lib/generators/active_conformity/install/install_generator.rb

@@ -0,0 +1,50 @@
+require 'rails/generators/active_record'
+module ActiveConformity
+  module Generators
+    class Install < Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+      desc "Creates the conformable model and table which stores the conformity sets as json
+      and the custom validation methods module in the lib directory."
+
+      def self.source_root
+        @source_root ||= File.expand_path('../templates', __FILE__)
+      end
+
+      def self.next_migration_number(path)
+        @migration_number = Time.now.strftime("%Y%m%d%H%M%S")
+      end
+
+      def generate_migration
+        migration_template "active_conformity_migration.rb.erb", "db/migrate/#{migration_file_name}"
+      end
+
+      def migration_name
+        "create_conformables"
+      end
+
+      def migration_class_name
+        migration_name.camelize
+      end
+
+      def migration_file_name
+        "#{migration_name}.rb"
+      end
+
+      def conformity_set_type
+        database_adapters.fetch(ActiveRecord::Base.connection.adapter_name, 'json')
+      end
+
+      def database_adapters
+        {
+          'MySQL' => 'json',
+          'PostgreSQL' => 'json' # This can be jsonb for 9.4 and above
+        }
+      end
+
+      def create_custom_methods_module_file
+        template "active_conformity_custom_validation_methods.rb.erb", "lib/active_conformity_custom_validation_methods.rb"
+      end
+    end
+  end
+end

data/lib/generators/active_conformity/install/templates/active_conformity_custom_validation_methods.rb.erb

@@ -0,0 +1,29 @@
+module ActiveConformityCustomMethods
+
+
+
+end
+
+=begin
+This file is for creating custom methods that you can add to the conformity set
+of a conformable. The object that these methods will run against is availible by
+calling 'obj'. Additionally, you can utilize any of the named arguments that
+were saved in the conformity set.
+
+For example:
+  For a conformable with the conformity_set like:
+
+  { method: { name: 'content_is?', arguments: {string: 'hello world' } } }
+
+  You can define the following method in this module:
+
+  def content_is?
+    if obj.content == method_args[:string]
+      return true
+    else
+      errors.add(:content, "does not match #{method_args[:string]}")
+    end
+  end
+
+  Be sure to follow the rails convention of adding errors in the false case!
+=end

data/lib/generators/active_conformity/install/templates/active_conformity_migration.rb.erb

@@ -0,0 +1,15 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :conformables do |t|
+      t.string :conformist_type
+      t.integer :conformable_id
+      t.string :conformable_type
+      t.<%=conformity_set_type%> :conformity_set
+
+    end
+  end
+
+  def self.down
+    drop_table :conformables
+  end
+end

data/tasks/test.rake

@@ -0,0 +1,12 @@
+require 'rspec/core/rake_task'
+
+task test: ['spec:unit']
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :spec do
+  desc "Run the unit specs"
+  RSpec::Core::RakeTask.new(:unit) do |t|
+    t.pattern = "spec/unit/**/*_spec.rb"
+  end
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: active_conformity
+version: !ruby/object:Gem::Version
+  version: 0.2.13
+platform: ruby
+authors:
+- dandlezzz
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !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: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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: sqlite3
+  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: Store Rails validations as JSON to serve via api and drive complex validation
+  logic.
+email:
+- danm@workwithopal.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_conformity.gemspec
+- bin/console
+- bin/setup
+- lib/.DS_Store
+- lib/active_conformity.rb
+- lib/active_conformity/conformable.rb
+- lib/active_conformity/conformable_extensions.rb
+- lib/active_conformity/conformity_set_validator.rb
+- lib/active_conformity/object_validator.rb
+- lib/active_conformity/reifiers.rb
+- lib/active_conformity/version.rb
+- lib/generators/active_conformity/install/install_generator.rb
+- lib/generators/active_conformity/install/templates/active_conformity_custom_validation_methods.rb.erb
+- lib/generators/active_conformity/install/templates/active_conformity_migration.rb.erb
+- tasks/test.rake
+homepage: http://www.github.com/dandlezzz/active_conformity
+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: Database driven validations.
+test_files: []