gigantron 0.1.2 → 0.1.3

data/History.txt

@@ -0,0 +1,22 @@
+== 0.1.3 2008-06-24
+* 2 major bugfixes:
+  * fix broken gem
+  * make dependencies part of the hoe configuration
+== 0.1.2 2008-06-22
+* 1 major enhancement
+  * Shoulda activerecord helpers are now bundled
+== 0.1.1 2008-06-19
+* 1 minor enhancement:
+  * Migrations are now created with model
+* 1 major bugfix:
+  * use camelcase instead of capitalize in code generators
+== 0.1.0 2008-06-18
+
+* Millions of major enhancements:
+  * Now uses ActiveRecord
+  * Better tests
+== 0.0.1 2008-05-31
+
+* 1 major enhancement:
+  * Initial release
+  * It works somewhat, will use in practice to see where it is headed

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Ben Hughes
+
+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/Manifest.txt

@@ -0,0 +1,65 @@
+History.txt
+License.txt
+Manifest.txt
+PostInstall.txt
+README.txt
+Rakefile
+app_generators/gigantron/USAGE
+app_generators/gigantron/gigantron_generator.rb
+app_generators/gigantron/templates/Rakefile
+app_generators/gigantron/templates/database.yml.example
+app_generators/gigantron/templates/initialize.rb
+app_generators/gigantron/templates/lib/shoulda/active_record_helpers.rb
+app_generators/gigantron/templates/lib/shoulda/general.rb
+app_generators/gigantron/templates/lib/shoulda/private_helpers.rb
+app_generators/gigantron/templates/tasks/import.rake
+app_generators/gigantron/templates/test/tasks/test_import.rb
+app_generators/gigantron/templates/test/test_helper.rb
+bin/gigantron
+config/hoe.rb
+config/requirements.rb
+gigantron_generators/mapreduce_task/USAGE
+gigantron_generators/mapreduce_task/mapreduce_task_generator.rb
+gigantron_generators/mapreduce_task/templates/mapreduce/mr_task.rb
+gigantron_generators/mapreduce_task/templates/tasks/task.rake
+gigantron_generators/mapreduce_task/templates/test/tasks/test_task.rb
+gigantron_generators/migration/USAGE
+gigantron_generators/migration/migration_generator.rb
+gigantron_generators/migration/templates/db/migrate/migration.rb
+gigantron_generators/model/USAGE
+gigantron_generators/model/model_generator.rb
+gigantron_generators/model/templates/models/model.rb
+gigantron_generators/model/templates/test/models/test_model.rb
+gigantron_generators/task/USAGE
+gigantron_generators/task/task_generator.rb
+gigantron_generators/task/templates/tasks/task.rake
+gigantron_generators/task/templates/test/tasks/test_task.rb
+lib/gigantron.rb
+lib/gigantron/migrator.rb
+lib/gigantron/tasks/db.rb
+lib/gigantron/tasks/test.rb
+lib/gigantron/version.rb
+script/console
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+test/template_database.yml
+test/template_database.yml.example
+test/template_migration.rb
+test/test_generator_helper.rb
+test/test_gigantron.rb
+test/test_gigantron_generator.rb
+test/test_helper.rb
+test/test_mapreduce_task_generator.rb
+test/test_migration_generator.rb
+test/test_model_generator.rb
+test/test_task_generator.rb
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.html.erb

data/PostInstall.txt

@@ -0,0 +1,4 @@
+
+For more information on gigantron, see http://gigantron.rubyforge.org
+
+Do you enjoy the tangy zip of miracle whip?

data/README.txt

@@ -0,0 +1,77 @@
+= Gigantron: Processor of Data
+
+http://gigantron.rubyforge.org
+http://github.com/schleyfox/gigantron
+
+== DESCRIPTION:
+
+Gigantron is a simple framework for the creation and organization of
+data processing projects. Data-processing transforms are created as Rake tasks
+and data is handled through ActiveRecord* models.
+
+* Will switch back to DataMapper once it plays nice with JRuby
+
+== FEATURES/PROBLEMS:
+
+Features:
+* Generates folder/file structure for new DP projects
+* Contains generators for both models and tasks
+
+== SYNOPSIS:
+
+Use:
+
+shell> $ gigantron projectname
+
+to generate the project folder and then
+
+shell> $ script/generate model modelname
+
+OR 
+
+shell> $ script/generate task taskname
+
+to add code.
+
+== REQUIREMENTS:
+
+* RubyGems
+* RubiGen
+* Rake
+* ActiveRecord
+* ActiveSupport
+* Shoulda
+
+== INSTALL:
+
+sudo gem install gigantron
+
+== HACKING:
+
+Check out the website for a quick overview of how to fiddle with the generators
+behind Gigantron. http://gigantron.rubyforge.org.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Ben Hughes
+
+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/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/app_generators/gigantron/USAGE

@@ -0,0 +1,7 @@
+Description: 
+Generate the directory and file structure for a gigantron project.
+
+  
+Usage:
+shell> $ gigantron projectname
+  

data/app_generators/gigantron/gigantron_generator.rb

@@ -0,0 +1,87 @@
+class GigantronGenerator < RubiGen::Base
+  
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+  
+  default_options :author => nil
+  
+  attr_reader :name
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @destination_root = File.expand_path(args.shift)
+    @name = base_name
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      # Ensure appropriate folder(s) exists
+      m.directory ''
+      BASEDIRS.each { |path| m.directory path }
+
+      # Create stubs
+      m.file "Rakefile", "Rakefile"
+      m.file "database.yml.example", "database.yml.example"
+      m.file "initialize.rb", "initialize.rb"
+
+      m.file "tasks/import.rake", "tasks/import.rake"
+
+      m.file "test/test_helper.rb", "test/test_helper.rb"
+
+      m.directory "test/models"
+      m.directory "test/tasks"
+
+      m.file "test/tasks/test_import.rb", "test/tasks/test_import.rb"
+
+      m.directory "lib/shoulda"
+      m.file "lib/shoulda/general.rb", "lib/shoulda/general.rb"
+      m.file "lib/shoulda/private_helpers.rb", "lib/shoulda/private_helpers.rb"
+      m.file "lib/shoulda/active_record_helpers.rb", 
+        "lib/shoulda/active_record_helpers.rb"
+
+     
+      m.dependency "install_rubigen_scripts", [destination_root, 'gigantron'], 
+        :shebang => options[:shebang], :collision => :force
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a ...
+
+USAGE: #{spec.name} name
+EOS
+    end
+
+    def add_options!(opts)
+      opts.separator ''
+      opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |options[:author]| }
+      opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+    
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+
+    # Installation skeleton.  Intermediate directories are automatically
+    # created so don't sweat their absence here.
+    BASEDIRS = %w(
+      tasks
+      db
+      models
+      lib
+      test
+      log
+    )
+end

data/app_generators/gigantron/templates/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'rake'
+require 'fileutils'
+
+GTRON_ENV = :real
+require 'initialize'
+
+require 'gigantron/tasks/test'
+require 'gigantron/tasks/db'
+
+Dir['tasks/**/*.rake'].each {|r| load r }
+

data/app_generators/gigantron/templates/database.yml.example

@@ -0,0 +1,9 @@
+# JRuby
+#:test:
+#  :adapter: jdbcsqlite3
+#  :url: jdbc:sqlite:db/test.sqlite3
+
+# Ruby 1.8
+#:test:
+#  :adapter: sqlite3
+#  :database: db/test.sqlite3

data/app_generators/gigantron/templates/initialize.rb

@@ -0,0 +1,34 @@
+# This file handles all the background initialization work that the programmer
+# shouldn't have to worry about.  
+# This includes database startup, common requires, activesupport, and other
+# magic.  I'm not sure if this is a good idea or not.
+
+# ENV works like in rails, except is :real or :test
+GTRON_ENV rescue GTRON_ENV = :real 
+
+GTRON_ROOT = File.dirname(__FILE__)
+
+require 'rubygems'
+require 'rake'
+
+require 'activesupport'
+#set up autoload paths
+Dependencies.load_paths << "#{GTRON_ROOT}/lib/"
+
+require 'active_record'
+
+
+def get_db_conn(env)
+  env = env.to_sym
+  #set up logging
+  ActiveRecord::Base.logger = Logger.new("#{GTRON_ROOT}/log/#{env}.log")
+
+  #load in dbs from database.yml
+  ActiveRecord::Base.establish_connection(
+    YAML::load(File.read("#{GTRON_ROOT}/database.yml"))[env])
+
+  #load all models
+  Dir["#{GTRON_ROOT}/models/**/*.rb"].each {|r| load r }
+
+  nil
+end

data/app_generators/gigantron/templates/lib/shoulda/active_record_helpers.rb

@@ -0,0 +1,604 @@
+module ThoughtBot # :nodoc:
+  module Shoulda # :nodoc:
+    # = Macro test helpers for your active record models
+    #
+    # These helpers will test most of the validations and associations for your ActiveRecord models.
+    #
+    #   class UserTest < Test::Unit::TestCase
+    #     should_require_attributes :name, :phone_number
+    #     should_not_allow_values_for :phone_number, "abcd", "1234"
+    #     should_allow_values_for :phone_number, "(123) 456-7890"
+    #     
+    #     should_protect_attributes :password
+    #     
+    #     should_have_one :profile
+    #     should_have_many :dogs
+    #     should_have_many :messes, :through => :dogs
+    #     should_belong_to :lover
+    #   end
+    #
+    # For all of these helpers, the last parameter may be a hash of options.
+    #
+    module ActiveRecord
+      # Ensures that the model cannot be saved if one of the attributes listed is not present.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/blank/</tt>
+      #
+      # Example:
+      #   should_require_attributes :name, :phone_number
+      #
+      def should_require_attributes(*attributes)
+        message = get_options!(attributes, :message)
+        message ||= /blank/
+        klass = model_class
+        
+        attributes.each do |attribute|
+          should "require #{attribute} to be set" do
+            object = klass.new
+            object.send("#{attribute}=", nil)
+            assert !object.valid?, "#{klass.name} does not require #{attribute}."
+            assert object.errors.on(attribute), "#{klass.name} does not require #{attribute}."
+            assert_contains(object.errors.on(attribute), message)
+          end
+        end
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes listed is not unique.
+      # Requires an existing record
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/taken/</tt>
+      # * <tt>:scoped_to</tt> - field(s) to scope the uniqueness to.
+      #
+      # Examples:
+      #   should_require_unique_attributes :keyword, :username
+      #   should_require_unique_attributes :name, :message => "O NOES! SOMEONE STOELED YER NAME!"
+      #   should_require_unique_attributes :email, :scoped_to => :name
+      #   should_require_unique_attributes :address, :scoped_to => [:first_name, :last_name]
+      #
+      def should_require_unique_attributes(*attributes)
+        message, scope = get_options!(attributes, :message, :scoped_to)
+        scope = [*scope].compact
+        message ||= /taken/
+        
+        klass = model_class
+        attributes.each do |attribute|
+          attribute = attribute.to_sym
+          should "require unique value for #{attribute}#{" scoped to #{scope.join(', ')}" if scope}" do
+            assert existing = klass.find(:first), "Can't find first #{klass}"
+            object = klass.new
+            
+            object.send(:"#{attribute}=", existing.send(attribute))
+            if !scope.blank?
+              scope.each do |s|
+                assert_respond_to object, :"#{s}=", "#{klass.name} doesn't seem to have a #{s} attribute."
+                object.send(:"#{s}=", existing.send(s))
+              end
+            end
+            
+            assert !object.valid?, "#{klass.name} does not require a unique value for #{attribute}."
+            assert object.errors.on(attribute), "#{klass.name} does not require a unique value for #{attribute}."
+            
+            assert_contains(object.errors.on(attribute), message)
+            
+            # Now test that the object is valid when changing the scoped attribute
+            # TODO:  There is a chance that we could change the scoped field
+            # to a value that's already taken.  An alternative implementation
+            # could actually find all values for scope and create a unique
+            # one.  
+            if !scope.blank?
+              scope.each do |s|
+                # Assume the scope is a foreign key if the field is nil
+                object.send(:"#{s}=", existing.send(s).nil? ? 1 : existing.send(s).next)
+              end
+
+              object.errors.clear
+              object.valid?
+              scope.each do |s|
+                assert_does_not_contain(object.errors.on(attribute), message, 
+                                        "after :#{s} set to #{object.send(s.to_sym)}")
+              end
+            end
+          end
+        end
+      end
+
+      # Ensures that the attribute cannot be set on mass update.
+      # Requires an existing record.
+      #
+      #   should_protect_attributes :password, :admin_flag
+      #
+      def should_protect_attributes(*attributes)
+        get_options!(attributes)
+        klass = model_class
+
+        attributes.each do |attribute|
+          attribute = attribute.to_sym
+          should "protect #{attribute} from mass updates" do
+            protected = klass.protected_attributes || []
+            accessible = klass.accessible_attributes || []
+
+            assert protected.include?(attribute.to_s) || !accessible.include?(attribute.to_s),
+                   (accessible.empty? ?
+                     "#{klass} is protecting #{protected.to_a.to_sentence}, but not #{attribute}." :
+                     "#{klass} has made #{attribute} accessible")
+          end
+        end
+      end
+  
+      # Ensures that the attribute cannot be set to the given values
+      # Requires an existing record
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/invalid/</tt>
+      #
+      # Example:
+      #   should_not_allow_values_for :isbn, "bad 1", "bad 2"
+      #
+      def should_not_allow_values_for(attribute, *bad_values)
+        message = get_options!(bad_values, :message)
+        message ||= /invalid/
+        klass = model_class
+        bad_values.each do |v|
+          should "not allow #{attribute} to be set to #{v.inspect}" do
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            object.send("#{attribute}=", v)
+            assert !object.save, "Saved #{klass} with #{attribute} set to \"#{v}\""
+            assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{v}\""
+            assert_contains(object.errors.on(attribute), message, "when set to \"#{v}\"")
+          end
+        end
+      end
+  
+      # Ensures that the attribute can be set to the given values.
+      # Requires an existing record
+      #
+      # Example:
+      #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
+      #
+      def should_allow_values_for(attribute, *good_values)
+        get_options!(good_values)
+        klass = model_class
+        good_values.each do |v|
+          should "allow #{attribute} to be set to #{v.inspect}" do
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            object.send("#{attribute}=", v)
+            object.save
+            assert_nil object.errors.on(attribute)
+          end
+        end
+      end
+
+      # Ensures that the length of the attribute is in the given range
+      # Requires an existing record
+      #
+      # Options:
+      # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/short/</tt>
+      # * <tt>:long_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/long/</tt>
+      #
+      # Example:
+      #   should_ensure_length_in_range :password, (6..20)
+      #
+      def should_ensure_length_in_range(attribute, range, opts = {})
+        short_message, long_message = get_options!([opts], :short_message, :long_message)
+        short_message ||= /short/
+        long_message  ||= /long/
+        
+        klass = model_class
+        min_length = range.first
+        max_length = range.last
+        same_length = (min_length == max_length)
+
+        if min_length > 0
+          should "not allow #{attribute} to be less than #{min_length} chars long" do
+            min_value = "x" * (min_length - 1)
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            object.send("#{attribute}=", min_value)
+            assert !object.save, "Saved #{klass} with #{attribute} set to \"#{min_value}\""
+            assert object.errors.on(attribute), 
+                   "There are no errors set on #{attribute} after being set to \"#{min_value}\""
+            assert_contains(object.errors.on(attribute), short_message, "when set to \"#{min_value}\"")
+          end
+        end
+
+        if min_length > 0
+          should "allow #{attribute} to be exactly #{min_length} chars long" do
+            min_value = "x" * min_length
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            object.send("#{attribute}=", min_value)
+            object.save
+            assert_does_not_contain(object.errors.on(attribute), short_message, "when set to \"#{min_value}\"")
+          end
+        end
+    
+        should "not allow #{attribute} to be more than #{max_length} chars long" do
+          max_value = "x" * (max_length + 1)
+          assert object = klass.find(:first), "Can't find first #{klass}"
+          object.send("#{attribute}=", max_value)
+          assert !object.save, "Saved #{klass} with #{attribute} set to \"#{max_value}\""
+          assert object.errors.on(attribute), 
+                 "There are no errors set on #{attribute} after being set to \"#{max_value}\""
+          assert_contains(object.errors.on(attribute), long_message, "when set to \"#{max_value}\"")
+        end
+
+        unless same_length
+          should "allow #{attribute} to be exactly #{max_length} chars long" do
+            max_value = "x" * max_length
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            object.send("#{attribute}=", max_value)
+            object.save
+            assert_does_not_contain(object.errors.on(attribute), long_message, "when set to \"#{max_value}\"")
+          end
+        end
+      end  
+      
+     # Ensures that the length of the attribute is at least a certain length
+     # Requires an existing record
+     #
+     # Options:
+     # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+     #   Regexp or string.  Default = <tt>/short/</tt>
+     #
+     # Example:
+     #   should_ensure_length_at_least :name, 3
+     #
+     def should_ensure_length_at_least(attribute, min_length, opts = {})
+        short_message = get_options!([opts], :short_message)
+        short_message ||= /short/
+     
+        klass = model_class
+     
+        if min_length > 0
+          min_value = "x" * (min_length - 1)
+          should "not allow #{attribute} to be less than #{min_length} chars long" do
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            object.send("#{attribute}=", min_value)
+            assert !object.save, "Saved #{klass} with #{attribute} set to \"#{min_value}\""
+            assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{min_value}\""
+            assert_contains(object.errors.on(attribute), short_message, "when set to \"#{min_value}\"")
+          end
+        end
+        should "allow #{attribute} to be at least #{min_length} chars long" do
+          valid_value = "x" * (min_length)
+          assert object = klass.find(:first), "Can't find first #{klass}"
+          object.send("#{attribute}=", valid_value)
+          assert object.save, "Could not save #{klass} with #{attribute} set to \"#{valid_value}\""
+        end
+      end
+
+      # Ensure that the attribute is in the range specified
+      # Requires an existing record
+      #
+      # Options:
+      # * <tt>:low_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/included/</tt>
+      # * <tt>:high_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/included/</tt>
+      #
+      # Example:
+      #   should_ensure_value_in_range :age, (0..100)
+      #
+      def should_ensure_value_in_range(attribute, range, opts = {})
+        low_message, high_message = get_options!([opts], :low_message, :high_message)
+        low_message  ||= /included/
+        high_message ||= /included/
+        
+        klass = model_class
+        min   = range.first
+        max   = range.last
+
+        should "not allow #{attribute} to be less than #{min}" do
+          v = min - 1
+          assert object = klass.find(:first), "Can't find first #{klass}"
+          object.send("#{attribute}=", v)
+          assert !object.save, "Saved #{klass} with #{attribute} set to \"#{v}\""
+          assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{v}\""
+          assert_contains(object.errors.on(attribute), low_message, "when set to \"#{v}\"")
+        end
+
+        should "allow #{attribute} to be #{min}" do
+          v = min
+          assert object = klass.find(:first), "Can't find first #{klass}"
+          object.send("#{attribute}=", v)
+          object.save
+          assert_does_not_contain(object.errors.on(attribute), low_message, "when set to \"#{v}\"")
+        end
+
+        should "not allow #{attribute} to be more than #{max}" do
+          v = max + 1
+          assert object = klass.find(:first), "Can't find first #{klass}"
+          object.send("#{attribute}=", v)
+          assert !object.save, "Saved #{klass} with #{attribute} set to \"#{v}\""
+          assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{v}\""
+          assert_contains(object.errors.on(attribute), high_message, "when set to \"#{v}\"")
+        end
+
+        should "allow #{attribute} to be #{max}" do
+          v = max
+          assert object = klass.find(:first), "Can't find first #{klass}"
+          object.send("#{attribute}=", v)
+          object.save
+          assert_does_not_contain(object.errors.on(attribute), high_message, "when set to \"#{v}\"")
+        end
+      end    
+      
+      # Ensure that the attribute is numeric
+      # Requires an existing record
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/number/</tt>
+      #
+      # Example:
+      #   should_only_allow_numeric_values_for :age
+      #
+      def should_only_allow_numeric_values_for(*attributes)
+        message = get_options!(attributes, :message)
+        message ||= /number/
+        klass = model_class
+        attributes.each do |attribute|
+          attribute = attribute.to_sym
+          should "only allow numeric values for #{attribute}" do
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            object.send(:"#{attribute}=", "abcd")
+            assert !object.valid?, "Instance is still valid"
+            assert_contains(object.errors.on(attribute), message)
+          end
+        end
+      end
+
+      # Ensures that the has_many relationship exists.  Will also test that the
+      # associated table has the required columns.  Works with polymorphic
+      # associations.
+      # 
+      # Options:
+      # * <tt>:through</tt> - association name for <tt>has_many :through</tt>
+      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.      
+      #
+      # Example:
+      #   should_have_many :friends
+      #   should_have_many :enemies, :through => :friends
+      #   should_have_many :enemies, :dependent => :destroy
+      #
+      def should_have_many(*associations)
+        through, dependent = get_options!(associations, :through, :dependent)
+        klass = model_class
+        associations.each do |association|
+          name = "have many #{association}"
+          name += " through #{through}" if through
+          name += " dependent => #{dependent}" if dependent
+          should name do
+            reflection = klass.reflect_on_association(association)
+            assert reflection, "#{klass.name} does not have any relationship to #{association}"
+            assert_equal :has_many, reflection.macro
+
+            associated_klass = (reflection.options[:class_name] || association.to_s.classify).constantize
+
+            if through
+              through_reflection = klass.reflect_on_association(through)
+              assert through_reflection, "#{klass.name} does not have any relationship to #{through}"
+              assert_equal(through, reflection.options[:through])
+            end
+
+            if dependent
+              assert_equal dependent.to_s, 
+                           reflection.options[:dependent].to_s, 
+                           "#{associated_klass.name} should have #{dependent} dependency"
+            end
+            
+            # Check for the existence of the foreign key on the other table
+            unless reflection.options[:through]
+              if reflection.options[:foreign_key]
+                fk = reflection.options[:foreign_key]
+              elsif reflection.options[:as]
+                fk = reflection.options[:as].to_s.foreign_key
+              else
+                fk = reflection.primary_key_name
+              end
+              
+              assert associated_klass.column_names.include?(fk.to_s),
+                     "#{associated_klass.name} does not have a #{fk} foreign key."
+            end
+          end
+        end
+      end
+
+      # Ensure that the has_one relationship exists.  Will also test that the
+      # associated table has the required columns.  Works with polymorphic
+      # associations.
+      #
+      # Example:
+      #   should_have_one :god # unless hindu
+      #
+      def should_have_one(*associations)
+        get_options!(associations)
+        klass = model_class
+        associations.each do |association|
+          should "have one #{association}" do
+            reflection = klass.reflect_on_association(association)
+            assert reflection, "#{klass.name} does not have any relationship to #{association}"
+            assert_equal :has_one, reflection.macro
+            
+            associated_klass = (reflection.options[:class_name] || association.to_s.camelize).constantize
+
+            if reflection.options[:foreign_key]
+              fk = reflection.options[:foreign_key]
+            elsif reflection.options[:as]
+              fk = reflection.options[:as].to_s.foreign_key
+              fk_type = fk.gsub(/_id$/, '_type')
+              assert associated_klass.column_names.include?(fk_type), 
+                     "#{associated_klass.name} does not have a #{fk_type} column."            
+            else
+              fk = klass.name.foreign_key
+            end
+            assert associated_klass.column_names.include?(fk.to_s), 
+                   "#{associated_klass.name} does not have a #{fk} foreign key."            
+          end
+        end
+      end
+  
+      # Ensures that the has_and_belongs_to_many relationship exists, and that the join
+      # table is in place.
+      #
+      #   should_have_and_belong_to_many :posts, :cars
+      #
+      def should_have_and_belong_to_many(*associations)
+        get_options!(associations)
+        klass = model_class
+
+        associations.each do |association|
+          should "should have and belong to many #{association}" do
+            reflection = klass.reflect_on_association(association)
+            assert reflection, "#{klass.name} does not have any relationship to #{association}"
+            assert_equal :has_and_belongs_to_many, reflection.macro
+            table = reflection.options[:join_table]
+            assert ::ActiveRecord::Base.connection.tables.include?(table), "table #{table} doesn't exist"
+          end
+        end
+      end
+  
+      # Ensure that the belongs_to relationship exists.
+      #
+      #   should_belong_to :parent
+      #
+      def should_belong_to(*associations)
+        get_options!(associations)
+        klass = model_class
+        associations.each do |association|
+          should "belong_to #{association}" do
+            reflection = klass.reflect_on_association(association)
+            assert reflection, "#{klass.name} does not have any relationship to #{association}"
+            assert_equal :belongs_to, reflection.macro
+
+            unless reflection.options[:polymorphic]
+              associated_klass = (reflection.options[:class_name] || association.to_s.classify).constantize
+              fk = reflection.options[:foreign_key] || reflection.primary_key_name
+              assert klass.column_names.include?(fk.to_s), "#{klass.name} does not have a #{fk} foreign key."
+            end
+          end
+        end
+      end
+      
+      # Ensure that the given class methods are defined on the model.
+      #
+      #   should_have_class_methods :find, :destroy
+      #
+      def should_have_class_methods(*methods)
+        get_options!(methods)
+        klass = model_class
+        methods.each do |method|
+          should "respond to class method ##{method}" do
+            assert_respond_to klass, method, "#{klass.name} does not have class method #{method}"
+          end
+        end
+      end
+
+      # Ensure that the given instance methods are defined on the model.
+      #
+      #   should_have_instance_methods :email, :name, :name=
+      #
+      def should_have_instance_methods(*methods)
+        get_options!(methods)
+        klass = model_class
+        methods.each do |method|
+          should "respond to instance method ##{method}" do
+            assert_respond_to klass.new, method, "#{klass.name} does not have instance method #{method}"
+          end
+        end
+      end
+
+      # Ensure that the given columns are defined on the models backing SQL table.
+      #
+      #   should_have_db_columns :id, :email, :name, :created_at
+      #
+      def should_have_db_columns(*columns)
+        column_type = get_options!(columns, :type)
+        klass = model_class
+        columns.each do |name|
+          test_name = "have column #{name}"
+          test_name += " of type #{column_type}" if column_type
+          should test_name do
+            column = klass.columns.detect {|c| c.name == name.to_s }
+            assert column, "#{klass.name} does not have column #{name}"
+          end
+        end
+      end
+
+      # Ensure that the given column is defined on the models backing SQL table.  The options are the same as
+      # the instance variables defined on the column definition:  :precision, :limit, :default, :null, 
+      # :primary, :type, :scale, and :sql_type.
+      #
+      #   should_have_db_column :email, :type => "string", :default => nil,   :precision => nil, :limit    => 255, 
+      #                                 :null => true,     :primary => false, :scale     => nil, :sql_type => 'varchar(255)'
+      #
+      def should_have_db_column(name, opts = {})
+        klass = model_class
+        test_name = "have column named :#{name}"
+        test_name += " with options " + opts.inspect unless opts.empty?
+        should test_name do
+          column = klass.columns.detect {|c| c.name == name.to_s }
+          assert column, "#{klass.name} does not have column #{name}"
+          opts.each do |k, v|
+            assert_equal column.instance_variable_get("@#{k}").to_s, v.to_s, ":#{name} column on table for #{klass} does not match option :#{k}"
+          end
+        end
+      end
+
+      # Ensures that there are DB indices on the given columns or tuples of columns.
+      # Also aliased to should_have_index for readability
+      #   
+      #   should_have_indices :email, :name, [:commentable_type, :commentable_id]
+      #   should_have_index :age
+      #
+      def should_have_indices(*columns)
+        table = model_class.name.tableize
+        indices = ::ActiveRecord::Base.connection.indexes(table).map(&:columns)
+
+        columns.each do |column|
+          should "have index on #{table} for #{column.inspect}" do
+            columns = [column].flatten.map(&:to_s)
+            assert_contains(indices, columns)
+          end
+        end
+      end
+
+      alias_method :should_have_index, :should_have_indices
+      
+      # Ensures that the model cannot be saved if one of the attributes listed is not accepted.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/must be accepted/</tt>
+      #
+      # Example:
+      #   should_require_acceptance_of :eula
+      #
+      def should_require_acceptance_of(*attributes)
+        message = get_options!(attributes, :message)
+        message ||= /must be accepted/
+        klass = model_class
+    
+        attributes.each do |attribute|
+          should "require #{attribute} to be accepted" do
+            object = klass.new
+            object.send("#{attribute}=", false)
+
+            assert !object.valid?, "#{klass.name} does not require acceptance of #{attribute}."
+            assert object.errors.on(attribute), "#{klass.name} does not require acceptance of #{attribute}."
+            assert_contains(object.errors.on(attribute), message)
+          end
+        end
+      end
+      
+      private
+      
+      include ThoughtBot::Shoulda::Private
+    end
+  end
+end