modelist 0.0.1

data/README.md

@@ -0,0 +1,105 @@
+Modelist
+=====
+
+CLI and API to test and analyze ActiveRecord models.
+
+### Setup
+
+In your Rails 3+ project, add this to your Gemfile:
+
+    gem 'modelist'
+
+Then run:
+
+    bundle install
+
+### API Configuration
+
+Not needed for CLI. Just used if you are using as an API:
+
+    Modelist::quiet = true
+
+### Usage
+
+#### CLI
+
+Modelist has a command-line interface with options to test for required circular dependencies, models that the specified models require due to nullable or validation constraints, or to test attributes and associations.
+
+##### Circular
+
+Check ActiveRecord circular dependencies. Find circular chains of dependencies where foreign keys that are not primary keys of the models are all not nullable in the schema or not nullable because of ActiveRecord presence validation with:
+
+    bundle exec modelist circular
+
+or:
+
+    bundle exec modelist circular my_model_1 my_model_2 --output-file=/path/to/errors.log
+
+Example output:
+
+    The following non-nullable foreign keys used in ActiveRecord model associations are involved in circular dependencies:
+
+    beers.waitress_id -> waitresses.bartender_id -> bartenders.beer_id -> beers.waitress_id
+
+    beers.waitress_id -> waitresses.bartender_id -> bartenders.order_id -> order.beer_id -> beers.waitress_id
+
+
+    Distinct foreign keys involved in a circular dependency:
+
+    beers.waitress_id
+    order.beer_id
+    bartenders.beer_id
+    bartenders.order_id
+    waitresses.bartender_id
+
+
+    Foreign keys by number of circular dependency chains involved with:
+
+    2 (out of 2): beers.waitress_id -> waitresses
+    2 (out of 2): waitresses.bartender_id -> bartenders
+    1 (out of 2): order.beer_id -> beers
+    1 (out of 2): bartenders.order_id -> order
+    1 (out of 2): bartenders.beer_id -> beers
+
+Specify '--output-file' to provide an pathname of an errors file.
+
+##### Required
+
+Find the models that the specified models have non-nullable or presence validations for directly and indirectly. You can use this to determine which models are really required with:
+
+    bundle exec modelist required my_model_1 my_model_2
+
+Example output:
+
+    Required models:
+
+    Bartender
+    Beer
+    Order
+    Waitress
+    
+##### Test
+
+Test ActiveRecord models, their attributes, and associations with:
+
+    bundle exec modelist test
+
+or:
+
+    bundle exec modelist test my_model_1 my_model_2 --output-file=/path/to/errors.log
+
+Example output:
+
+Specify '--output-file' to provide an pathname of an errors file.
+
+### API
+
+    Modelist::Analyst.find_required_models(:model1, :model2)
+    Modelist::CircularRefChecker.test_models(:model1, :model2, output_file: true)
+    Modelist::Tester.test_models(:model1, :model2, output_file: true)
+
+### License
+
+Copyright (c) 2012 Gary S. Weaver, released under the [MIT license][lic].
+
+[lic]: http://github.com/garysweaver/modelist/blob/master/LICENSE

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+
+#http://nicksda.apotomo.de/2010/10/testing-your-rails-3-engine-sitting-in-a-gem/
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+desc "Run tests"
+task :default => :test

data/bin/modelist

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'modelist'
+require 'modelist/cli'

data/lib/modelist/analyst.rb

@@ -0,0 +1,97 @@
+module Modelist
+  class Analyst
+
+    # Check refs on all models or models specified, e.g.
+    #   Modelist::Analyst.find_model_requirements
+    # or
+    #   Modelist::Analyst.find_model_requirements(:my_model, :some_other_model)
+    def self.find_required_models(*args)
+      # less-dependent extract_options!
+      #options = args.last.is_a?(Hash) ? args.pop : {}
+      raise ArgumentError.new("Please supply one or more models") unless args.size > 0
+      results = {}
+      models = []
+      included_models = args.compact.collect{|m|m.to_sym}
+      puts "Checking models: #{included_models.collect{|m|m.inspect}.join(', ')}" if !Modelist.quiet? && included_models.size > 0
+      Dir[File.join('app','models','*.rb').to_s].each do |filename|
+        model_name = File.basename(filename).sub(/.rb$/, '')
+        next if included_models.size > 0 && !included_models.include?(model_name.to_sym)
+        load File.join('app','models',"#{model_name}.rb")
+        
+        begin
+          model_class = model_name.camelize.constantize
+        rescue => e
+          puts "Problem in #{model_name.camelize}" unless Modelist.quiet?
+          raise e
+        end
+
+        next unless model_class.ancestors.include?(ActiveRecord::Base)
+        models << model_class
+      end
+
+      models.each do |model_class|
+        test_model(model_class, results)
+      end
+
+      unless Modelist.quiet? || !results[:required_models]
+        puts "Required models:"
+        puts
+        results[:required_models].collect{|c|c.name}.sort.each do |c|
+          puts "#{c}"
+        end
+        puts
+      end
+
+      return results[:required_models] ? results[:required_models] : []
+    end
+
+    # Get hash of required model information including non-nullable or validation presence associations throughout associations tree for model specified, e.g.
+    #   Modelist::Analyst.test_model(:my_model)
+    # Also can take model class:
+    #   Modelist::Analyst.test_model(MyModel)
+    def self.test_model(model_class, results = nil, model_and_association_names = [])
+      model_class = model_class.to_s.camelize.constantize unless model_class.is_a?(Class)
+
+      results ||= {}
+      results[:required_models] ||= []
+      results[:required_models] << model_class unless results[:required_models].include?(model_class)
+
+      model_class.reflections.collect {|association_name, reflection|
+        puts "warning: #{model_class}'s association #{reflection.name}'s foreign_key was nil. can't check." unless reflection.foreign_key || Modelist.quiet?
+        assc_sym = reflection.name.to_sym
+        
+        begin
+          next_class = reflection.class_name.constantize
+        rescue => e
+          puts "Problem in #{model_class.name} with association: #{reflection.macro} #{assc_sym.inspect} which refers to class #{reflection.class_name}" unless Modelist.quiet?
+          raise e
+        end
+
+        has_presence_validator = model_class.validators_on(assc_sym).collect{|v|v.class}.include?(ActiveModel::Validations::PresenceValidator)
+        required = false
+        if reflection.macro == :belongs_to
+          # note: supports composite_primary_keys gem which stores primary_key as an array
+          foreign_key_is_also_primary_key = Array.wrap(model_class.primary_key).collect{|pk|pk.to_sym}.include?(reflection.foreign_key.to_sym)
+          is_not_null_fkey_that_is_not_primary_key = model_class.columns.any?{|c| !c.null && c.name.to_sym == reflection.foreign_key.to_sym && !foreign_key_is_also_primary_key}
+          required = is_not_null_fkey_that_is_not_primary_key || has_presence_validator
+        else
+          # no nullable metadata on column if no foreign key in this table. we'd figure out the null requirement on the column if inspecting the child model
+          required = has_presence_validator
+        end
+
+        puts "#{model_class.name}.#{association_name} #{required ? 'required' : 'not required'}"
+
+        if required
+          key = [model_class.table_name.to_sym, reflection.foreign_key.to_sym, next_class.table_name.to_sym]
+          unless model_and_association_names.include?(key)
+            model_and_association_names << key
+            test_model(next_class, results, model_and_association_names)
+          end
+        end
+      }
+
+      model_and_association_names.pop
+      results
+    end
+  end
+end

data/lib/modelist/circular_ref_checker.rb

@@ -0,0 +1,169 @@
+module Modelist
+  class CircularRefChecker
+
+    # Check refs on all models or models specified, e.g.
+    #   Modelist::CircularRefChecker.test_models
+    # or
+    #   Modelist::CircularRefChecker.test_models(:my_model, :some_other_model)
+    def self.test_models(*args)
+      # less-dependent extract_options!
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      results = {}
+      models = []
+      included_models = args.compact.collect{|m|m.to_sym}
+      puts "Checking models: #{included_models.collect{|m|m.inspect}.join(', ')}" if !Modelist.quiet? && included_models.size > 0
+      Dir[File.join('app','models','*.rb').to_s].each do |filename|
+        model_name = File.basename(filename).sub(/.rb$/, '')
+        next if included_models.size > 0 && !included_models.include?(model_name.to_sym)
+        load File.join('app','models',"#{model_name}.rb")
+        
+        begin
+          model_class = model_name.camelize.constantize
+        rescue => e
+          puts "Problem in #{model_name.camelize}" unless Modelist.quiet?
+          raise e
+        end
+
+        next unless model_class.ancestors.include?(ActiveRecord::Base)
+        models << model_class
+      end
+
+      models.each do |model_class|
+        test_model(model_class, results)
+      end
+
+      if results[:circles].nil? || results[:circles].size == 0
+        unless Modelist.quiet?
+          puts
+          puts "No circular dependencies."
+          puts
+        end
+        return true
+      end
+
+      if !Modelist.quiet? || options[:output_file]
+        totals = {}
+        results[:circles_sorted].each do |arr|
+          arr.each do |key|
+            totals[key] = 0 unless totals[key]
+            totals[key] = totals[key] + 1
+          end
+        end
+
+        unless Modelist.quiet?
+          puts  "The following non-nullable foreign keys used in ActiveRecord model associations are involved in circular dependencies:"
+          results[:circles].sort.each do |c|
+            puts
+            puts "#{c}"
+          end
+          puts
+          puts
+          puts "Distinct foreign keys involved in a circular dependency:"
+          puts
+          results[:offenders].sort.each do |c|
+            puts "#{c[0]}.#{c[1]}"
+          end
+          puts
+          puts
+          puts "Foreign keys by number of circular dependency chains involved with:"
+          puts
+          totals.sort_by {|k,v| v}.reverse.each do |arr|
+            c = arr[0]
+            t = arr[1]
+            puts "#{t} (out of #{results[:circles_sorted].size}): #{c[0]}.#{c[1]} -> #{c[2]}"
+          end
+          puts
+        end
+
+        if options[:output_file]
+          File.open(options[:output_file], "w") do |f|
+            f.puts  "The following non-nullable foreign keys used in ActiveRecord model associations are involved in circular dependencies:"
+            results[:circles].sort.each do |c|
+              f.puts
+              f.puts "#{c}"
+            end
+            f.puts
+            f.puts
+            f.puts "Distinct foreign keys involved in a circular dependency:"
+            f.puts
+            results[:offenders].sort.each do |c|
+              f.puts "#{c[0]}.#{c[1]}"
+            end
+            f.puts
+            f.puts
+            f.puts "Foreign keys by number of circular dependency chains involved with:"
+            f.puts
+            totals.sort_by {|k,v| v}.reverse.each do |arr|
+              c = arr[0]
+              t = arr[1]
+              f.puts "#{t} (out of #{results[:circles_sorted].size}): #{c[0]}.#{c[1]} -> #{c[2]}"
+            end
+            f.puts
+          end
+        end
+      end
+
+      return false
+    end
+
+    # Get hash of circular reference information about associations tree on model specified, e.g.
+    #   Modelist::CircularRefChecker.test_model(:my_model)
+    # Also can take model class:
+    #   Modelist::CircularRefChecker.test_model(MyModel)
+    def self.test_model(model_class, results = nil, model_and_association_names = [])
+      model_class = model_class.to_s.camelize.constantize unless model_class.is_a?(Class)
+
+      results ||= {}
+      results[:offenders] ||= []
+      results[:circles_sorted] ||= []
+      results[:circles] ||= []
+      results[:selected_offenders] ||= []
+
+      model_class.reflections.collect {|association_name, reflection|
+        puts "warning: #{model_class}'s association #{reflection.name}'s foreign_key was nil. can't check." unless reflection.foreign_key || Modelist.quiet?
+        assc_sym = reflection.name.to_sym
+        
+        begin
+          next_class = reflection.class_name.constantize
+        rescue => e
+          puts "Problem in #{model_class.name} with association: #{reflection.macro} #{assc_sym.inspect} which refers to class #{reflection.class_name}" unless Modelist.quiet?
+          raise e
+        end
+
+        has_presence_validator = model_class.validators_on(assc_sym).collect{|v|v.class}.include?(ActiveModel::Validations::PresenceValidator)
+        required = false
+        if reflection.macro == :belongs_to
+          # note: supports composite_primary_keys gem which stores primary_key as an array
+          foreign_key_is_also_primary_key = Array.wrap(model_class.primary_key).collect{|pk|pk.to_sym}.include?(reflection.foreign_key.to_sym)
+          is_not_null_fkey_that_is_not_primary_key = model_class.columns.any?{|c| !c.null && c.name.to_sym == reflection.foreign_key.to_sym && !foreign_key_is_also_primary_key}
+          required = is_not_null_fkey_that_is_not_primary_key || has_presence_validator
+        else
+          # no nullable metadata on column if no foreign key in this table. we'd figure out the null requirement on the column if inspecting the child model
+          required = has_presence_validator
+        end
+
+        if required
+          key = [model_class.table_name.to_sym, reflection.foreign_key.to_sym, next_class.table_name.to_sym]
+          if model_and_association_names.include?(key)
+            results[:offenders] << model_and_association_names.last unless results[:offenders].include?(model_and_association_names.last)
+            short = model_and_association_names.dup
+            # drop all preceding keys that have nothing to do with the circle
+            (short.index(key)).times {short.delete_at(0)}
+            sorted = short.sort
+            unless results[:circles_sorted].include?(sorted)
+              results[:circles_sorted] << sorted
+              results[:circles] << "#{(short + [key]).collect{|b|"#{b[0]}.#{b[1]}"}.join(' -> ')}".to_sym
+            end
+          else
+            model_and_association_names << key
+            test_model(next_class, results, model_and_association_names)
+          end
+        end
+      }
+
+      model_and_association_names.pop
+
+      results
+    end
+  end
+end

data/lib/modelist/cli.rb

@@ -0,0 +1,44 @@
+require 'thor'
+
+module Modelist
+  class CLI < Thor
+    desc "test", "Tests specified models, their attributes, and their associations. Will test all models if no models are specified."
+    method_option :output_file, :desc => "Pathname of file to output to"
+    def test(*args)
+      # load Rails environment
+      require './config/environment'
+      require 'modelist/tester'
+      #args = options[:models] ? options.delete(:models).split(',').collect{|s|s.strip} << options : []
+      puts "args=#{args.inspect}"
+      args.each {|a| puts "Unsupported option: #{args.delete(a)}" if a.to_s.starts_with?('-')}
+      exit ::Modelist::Tester.test_models(*args) ? 0 : 1
+    end
+
+    desc "required", "Finds model dependencies in specified models."
+    def required(*args)
+      # load Rails environment
+      require './config/environment'
+      require 'modelist/analyst'
+      # args are [*options[:models], options hash (minus the models)]
+      #args = options[:models] ? options.delete(:models).split(',').collect{|s|s.strip} << options : []
+      puts "args=#{args.inspect}"
+      args.each {|a| puts "Unsupported option: #{args.delete(a)}" if a.to_s.starts_with?('-')}
+      Modelist::Analyst.find_required_models(*args)
+      exit 0
+    end
+
+    desc "circular", "Checks for required circular references in specified models. Will test all models if no models are specified."
+    method_option :output_file, :desc => "Pathname of file to output to"
+    def circular(*args)
+      # load Rails environment
+      require './config/environment'
+      require 'modelist/circular_ref_checker'
+      #args = options[:models] ? options.delete(:models).split(',').collect{|s|s.strip} << options : []
+      puts "args=#{args.inspect}"
+      args.each {|a| puts "Unsupported option: #{args.delete(a)}" if a.to_s.starts_with?('-')}
+      exit ::Modelist::CircularRefChecker.test_models(*args) ? 0 : 1
+    end
+  end
+end
+
+::Modelist::CLI.start

data/lib/modelist/config.rb

@@ -0,0 +1,11 @@
+# If you use Modelist in an application, you can specify:
+#   Modelist.quiet = true
+# to limit output.
+module Modelist
+  OPTIONS = [:quiet]
+
+  class << self
+    OPTIONS.each{|o|attr_accessor o; define_method("#{o}?".to_sym){!!send("#{o}")}}
+    def configure(&blk); class_eval(&blk); end
+  end
+end

data/lib/modelist/tester.rb

@@ -0,0 +1,184 @@
+module Modelist
+  class Tester
+
+    # Check refs on all models or models specified, e.g.
+    #   Modelist::Tester.test_models
+    # or
+    #   Modelist::Tester.test_models(:my_model, :some_other_model)
+    def self.test_models(*args)
+      # less-dependent extract_options!
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      results = {}
+      models = []
+      included_models = args.compact.collect{|m|m.to_sym}
+      puts "Checking models: #{included_models.collect{|m|m.inspect}.join(', ')}" if !Modelist.quiet? && included_models.size > 0
+      Dir[File.join('app','models','*.rb').to_s].each do |filename|
+        model_name = File.basename(filename).sub(/.rb$/, '')
+        next if included_models.size > 0 && !included_models.include?(model_name.to_sym)
+        load File.join('app','models',"#{model_name}.rb")
+        
+        begin
+          model_class = model_name.camelize.constantize
+        rescue => e
+          puts "Problem in #{model_name.camelize}" unless Modelist.quiet?
+          results[:failures] << "FAILED: #{model_name}\n\n---\n\n#{filename}\n---\n#{formatted_errors.join("\n")}\n\n"
+          results[:failed] << model_class_name
+          raise e
+        end
+
+        next unless model_class.ancestors.include?(ActiveRecord::Base)
+        models << model_class
+      end
+
+      models.each do |model_class|
+        test_model(model_class, results)
+      end
+
+      unless Modelist.quiet?
+        puts "Done testing"
+        puts ""
+        puts ""
+
+        # Write warnings to file and console
+        if results[:failures] && results[:failures].size > 0
+          unless Modelist.quiet? 
+            puts "Failures:"
+            puts
+            results[:failures].sort.each do |failure|
+              puts *(failure.split('\n'))
+            end
+          end
+          
+          if options[:output_file]
+            File.open(options[:output_file], "w") do |f|
+              f.puts "Failures:"
+              f.puts
+              results[:failures].sort.each do |failure|
+                f.puts *(failure.split('\n'))
+              end
+            end
+
+            unless Modelist.quiet?
+              puts ""
+              puts "Errors in #{ERRORS_FILE}"
+            end
+          end
+        end
+
+        unless Modelist.quiet? || !results[:passed]
+          puts
+          puts "Passed (#{results[:passed].size}):"
+          puts "---"
+          results[:passed].each do |s|
+            puts s
+          end
+          puts
+          puts "Warnings (#{results[:warnings].size}):"
+          puts "---"
+          results[:warnings].each do |s|
+            puts s
+          end
+          puts
+          puts "Failed (#{results[:failed].size}):"
+          puts "---"
+          results[:failed].each do |s|
+            puts s
+          end
+        end
+      end
+
+      return results[:failed] ? results[:failed].size > 0 : true
+    end
+
+    # Test and get hash of information about model specified, e.g.
+    #   Modelist::Tester.test_associations(:my_model)
+    # Also can take model class:
+    #   Modelist::Tester.test_associations(MyModel)
+    def self.test_model(model_class, results = nil)
+      model_class = model_class.to_s.camelize.constantize unless model_class.is_a?(Class)
+
+      results ||= {}
+      results[:passed] ||= []
+      results[:warnings] ||= []
+      results[:failed] ||= []
+      results[:failures] ||= []
+
+      puts "Testing #{model_class}"
+      method_name_to_exception = {}
+      if model_class
+        
+        model = nil
+
+        begin          
+          model = model_class.first
+          puts "#{model_class}.first = #{model.inspect}"
+          if model.nil?
+            results[:warnings] << "#{model_class.name}.first was nil. Assuming there is no data in the associated table, but please verify."
+          end
+        rescue Exception => e
+          method_name_to_exception["#{model_class.name}.first"] = e
+        end
+
+        if model
+          begin          
+            model = model_class.last
+            puts "#{model_class}.last = #{model.inspect}"
+            if model.nil?
+              results[:warnings] << "#{model_class.name}.last was nil."
+            end
+          rescue Exception => e
+            method_name_to_exception["#{model_class.name}.last"] = e
+          end
+        end
+
+        if model
+          attrs = model.attributes.keys
+          attrs.each do |attr|
+            begin
+              result = model.read_attribute(attr)
+              if result.is_a? Array
+                size = result.size
+                puts "#{model_class.name.underscore}.#{attr}.size = #{size}"
+              else
+                puts "#{model_class.name.underscore}.#{attr} = #{result}"
+              end
+            rescue Exception => e
+              method_name_to_exception["#{model_class.name}.#{attr}"] = e
+            end
+          end
+        end
+
+        model_class.reflections.collect do |association_name, reflection|
+          begin
+            reflection.class_name
+          rescue Exception => e
+            method_name_to_exception["#{model_class.name}'.{association_name}'s reflection class_name method"] = e
+            next
+          end
+
+          model = model_class.new unless model
+          begin
+            value = model.send(association_name.to_sym)
+            if value.nil?
+              #results[:warnings] << "(ignore) #{model_class_name}.#{association_name} was nil"
+            elsif (value.is_a?(Array) && value.size == 0)
+              #results[:warnings] << "(ignore) #{model_class_name}.#{association_name} was empty"
+            end
+          rescue Exception => e
+            method_name_to_exception["#{model_class.name}.last.#{association_name}"] = e
+          end
+        end
+      end
+
+      if method_name_to_exception.size > 0
+        formatted_errors = method_name_to_exception.keys.collect{|method_name|"#{method_name}: #{method_name_to_exception[method_name].message}\n#{method_name_to_exception[method_name].backtrace.join("\n")}\n---\n"}
+        results[:failures] << "FAILED: #{model_class.name}\n\n---\n#{formatted_errors.join("\n")}\n\n"
+        results[:failed] << model_class.name
+      else
+        results[:passed] << model_class.name
+      end
+
+      results
+    end
+  end
+end

data/lib/modelist/version.rb

@@ -0,0 +1,3 @@
+module Modelist
+  VERSION = '0.0.1'
+end

data/lib/modelist.rb

@@ -0,0 +1,5 @@
+require 'modelist/version'
+require 'modelist/config'
+require 'modelist/analyst'
+require 'modelist/circular_ref_checker'
+require 'modelist/tester'

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: modelist
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gary S. Weaver
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: CLI and API to perform basic testing of all models, their attributes,
+  and their associations, and determine what models are depended on directly and indirectly
+  by a specific model.
+email:
+- garysweaver@gmail.com
+executables:
+- modelist
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/modelist/analyst.rb
+- lib/modelist/circular_ref_checker.rb
+- lib/modelist/cli.rb
+- lib/modelist/config.rb
+- lib/modelist/tester.rb
+- lib/modelist/version.rb
+- lib/modelist.rb
+- Rakefile
+- README.md
+- bin/modelist
+homepage: https://github.com/garysweaver/modelist
+licenses:
+- MIT
+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: Tests and analyzes requirements of your ActiveRecord models.
+test_files: []