table_warnings 0.0.7 → 1.0.0

data/.gitignore

@@ -4,3 +4,4 @@ pkg/*
 rdoc/*
 data_miner.log
 Gemfile.lock
+.DS_Store

data/CHANGELOG

@@ -0,0 +1,14 @@
+1.0.0 / 2012-06-07
+
+* Breaking changes
+
+  * Renamed plain warn -> warn_if to avoid conflict with Kernel.warn
+  * Got rid of _in and _is suffixes, so warn_if_blanks_in -> warn_if_blanks
+
+* Enhancements
+
+  * Proper unit tests
+  * Added warn_if_nulls_except
+  * Added warn_if_nonexistent_owner[_except]
+  * Added warn_unless_range
+  * Got rid of autoload

data/Gemfile

@@ -1,4 +1,3 @@
-source "http://rubygems.org"
+source :rubygems
 
-# Specify your gem's dependencies in table_warnings.gemspec
 gemspec

data/README.rdoc

@@ -5,9 +5,9 @@ NOTE: only for activerecord right now because it uses <tt>count(:conditions => [
 ==How to define warning signs
 
     class AutomobileMake < ActiveRecord::Base
-      warn_if_blanks_in :name
-      warn_if_blanks_in :fuel_efficiency
-      warn_unless_size_is :hundreds
+      warn_if_blanks :name
+      warn_if_blanks :fuel_efficiency
+      warn_unless_size :hundreds
     end
 
 ==How to see warnings for the table

data/Rakefile

@@ -1,5 +1,5 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
 
 require 'rake'
 require 'rake/testtask'
@@ -11,12 +11,7 @@ end
 
 task :default => :test
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = TableWarnings::VERSION
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "table_warnings #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+require 'yard'
+YARD::Rake::YardocTask.new do |y|
+  y.options << '--no-private'
 end

data/lib/table_warnings/arbitrary.rb

@@ -0,0 +1,17 @@
+module TableWarnings
+  class Arbitrary
+    attr_reader :table
+    attr_reader :blk
+
+    def initialize(table, blk)
+      @table = table
+      @blk = blk
+    end
+    
+    def messages
+      if messages = table.instance_eval(&blk)
+        [messages].flatten.select { |message| message.present? }
+      end
+    end
+  end
+end

data/lib/table_warnings/blank.rb

@@ -0,0 +1,13 @@
+module TableWarnings
+  class Blank < Exclusive
+    def message(column)
+      if column.nulls?(conditions) or (column.string? and column.blanks?(conditions))
+        if conditions.empty?
+          "There are blanks in the #{column.name.inspect} column."
+        else
+          "There are blanks with the condition #{conditions.inspect} in the #{column.name.inspect} column."
+        end
+      end
+    end
+  end
+end

data/lib/table_warnings/column.rb

@@ -0,0 +1,70 @@
+module TableWarnings
+  class Column
+    attr_reader :table
+    attr_reader :name
+    
+    def initialize(table, name)
+      @table = table
+      @name = name.to_s
+    end
+
+    def nulls?(conditions)
+      table.where(conditions).where(name => nil).count > 0
+    end
+
+    def string?
+      table.columns_hash[name].try(:type) == :string
+    end
+
+    def blank?(conditions)
+      table.where(conditions).where(["LENGTH(TRIM(#{table.quoted_table_name}.#{name})) = 0"]).count > 0
+    end
+
+    def values_outside?(min, max, conditions)
+      t = table.arel_table
+      range_conditions = if min and max
+        t[name].lt(min).or(t[name].gt(max))
+      elsif min
+        t[name].lt(min)
+      elsif max
+        t[name].lt(max)
+      else
+        raise RuntimeError, "Either max or min or both should be defined"
+      end
+      table.where(conditions).where(range_conditions.and(t[name].not_eq(nil))).count > 0
+    end
+
+    def min
+      table.minimum(name)
+    end
+
+    def max
+      table.maximum(name)
+    end
+
+    # select zip_codes.* from zip_codes left join egrid_subregions on `egrid_subregions`.`abbreviation` = zip_codes.`egrid_subregion_abbreviation` where `egrid_subregions`.`abbreviation` is null
+    # t.project('COUNT(*)').join(a_t, Arel::Nodes::OuterJoin).on(a_t[assoc.association_primary_key].eq(t[assoc.foreign_key])).where(a_t[assoc.klass.primary_key].eq(nil))
+    def nonexistent_owners?(conditions)
+      relation = table.includes(association.name).where(
+        table.arel_table[association.foreign_key].not_eq(nil).and(      # not this query's job
+        association.klass.arel_table[association.klass.primary_key].eq(nil))  # columns in the right table are set to NULL if they don't exist
+      )
+      if conditions.empty?
+        relation.count > 0
+      else
+        relation.where(conditions).count > 0
+      end
+    end
+
+    def association
+      return @association.first if @association.is_a?(Array) # ruby needs an easy way to memoize things that might be false or nil
+      @association = table.reflect_on_all_associations(:belongs_to).select do |assoc|
+        assoc.foreign_key == name
+      end
+      if @association.many?
+        raise ArgumentError, "More than one association on #{table.name} uses foreign key #{name.inspect}"
+      end
+      @association.first
+    end
+  end
+end

data/lib/table_warnings/debug.rb

@@ -0,0 +1,2 @@
+ENV['TABLE_WARNINGS_DEBUG'] = 'true'
+ENV['TABLE_WARNINGS_STRICT'] = 'true'

data/lib/table_warnings/exclusive.rb

@@ -0,0 +1,31 @@
+module TableWarnings
+  class Exclusive
+    attr_reader :table
+    attr_reader :scout
+    attr_reader :conditions
+
+    def initialize(table, matcher, options = {})
+      @table = table
+      @conditions = options[:conditions] || {}
+      @scout = Scout.new table, matcher, options
+    end
+
+    def exclusives(columns)
+      columns.select { |column| scout.exclusive? column }
+    end
+
+    def matches(columns)
+      columns.select { |column| scout.match? column }
+    end
+
+    def covers(columns)
+      columns.select { |column| scout.cover? column }
+    end
+
+    def messages(columns)
+      columns.map do |column|
+        message column
+      end
+    end
+  end
+end

data/lib/table_warnings/nonexistent_owner.rb

@@ -0,0 +1,31 @@
+module TableWarnings
+  class NonexistentOwner < Exclusive
+    def initialize(table, matcher, options = {})
+      super
+      scout.enable_association_check!
+      @allow_null_query = options[:allow_null]
+    end
+
+    def message(column)
+      if column.nonexistent_owners?(conditions) or (not allow_null? and column.nulls?(conditions))
+        if conditions.empty?
+          "Foreign keys#{null_warning} refer to nonexistent values in #{column.name.inspect}"
+        else
+          "Foreign keys#{null_warning} refer to nonexistent values in #{column.name.inspect} given #{conditions.inspect}"
+        end
+      end
+    end
+
+    private
+
+    def allow_null?
+      @allow_null_query
+    end
+
+    def null_warning
+      if not allow_null?
+        ' are nil and/or'
+      end
+    end
+  end
+end

data/lib/table_warnings/null.rb

@@ -0,0 +1,13 @@
+module TableWarnings
+  class Null < Exclusive
+    def message(column)
+      if column.nulls?(conditions)
+        if conditions.empty?
+          "There are NULLs in the #{column.name.inspect} column."
+        else
+          "There are NULLs with the conditions #{conditions.inspect} in the #{column.name.inspect} column."
+        end
+      end
+    end
+  end
+end

data/lib/table_warnings/range.rb

@@ -0,0 +1,32 @@
+module TableWarnings
+  class Range < Exclusive
+    attr_reader :max
+    attr_reader :min
+
+    def initialize(table, matcher, options = {})
+      super
+      @min = options[:min]
+      @max = options[:max]
+      @allow_null_query = options[:allow_null]
+      if min and max and min > max
+        raise ArgumentError, "Min #{min.inspect} must be less than max #{max.inspect}"
+      end
+    end
+
+    def message(column)
+      if column.values_outside?(min, max, conditions) or (not allow_null? and column.nulls?(conditions))
+        if conditions.empty?
+          "Unexpected range for #{column.name.inspect}. Min: #{column.min.inspect} (expected #{min.inspect}) Max: #{column.max.inspect} (expected #{max.inspect})"
+        else
+          "Unexpected range for #{column.name.inspect} in #{conditions.inspect}. Min: #{column.min.inspect} (expected #{min.inspect}) Max: #{column.max.inspect} (expected #{max.expect})"
+        end
+      end
+    end
+
+    private
+
+    def allow_null?
+      @allow_null_query
+    end
+  end
+end

data/lib/table_warnings/registry.rb

@@ -0,0 +1,38 @@
+module TableWarnings
+  class Registry
+    attr_reader :warnings
+
+    def initialize
+      @warnings = {}
+      @warnings_mutex = Mutex.new
+    end
+
+    def add_warning(table, warning)
+      @warnings_mutex.synchronize do
+        warnings[table.to_s] ||= []
+        warnings[table.to_s] << warning
+      end
+    end
+
+    def warnings_for(table)
+      k = table.to_s
+      if warnings.has_key?(k)
+        warnings[k].dup
+      else
+        []
+      end
+    end
+
+    def exclusive(table)
+      warnings_for(table).select do |warning|
+        warning.respond_to? :exclusives
+      end
+    end
+
+    def nonexclusive(table)
+      warnings_for(table).reject do |warning|
+        warning.respond_to? :exclusives
+      end
+    end
+  end
+end

data/lib/table_warnings/scout.rb

@@ -0,0 +1,85 @@
+module TableWarnings
+  class Scout
+    attr_reader :table
+    attr_reader :matcher
+    attr_reader :conditions
+    
+    def initialize(table, matcher, options = {})
+      @table = table
+      @matcher = matcher
+      @positive_query = (options[:negative] != true)
+      @conditions_query = case options[:conditions]
+      when String
+        true
+      when Hash, Array
+        !options[:conditions].empty?
+      else
+        false
+      end
+    end
+
+    def exclusive?(column)
+      match?(column) and unambiguous?
+    end
+
+    def match?(column)
+      if association_check? and not column.association
+        return false
+      end
+      if positive?
+        cover? column
+      else
+        not cover?(column)
+      end
+    end
+
+    def cover?(column)
+      column_name = column.name
+      if association_check?
+        associations.any? do |a|
+          a.foreign_key == column_name
+        end
+      else
+        case matcher
+        when Regexp
+          !!(column_name =~ matcher)
+        else
+          column_name.to_s == matcher.to_s
+        end
+      end
+    end
+
+    def enable_association_check!
+      @association_check_query = true
+    end
+
+    private
+
+    def association_check?
+      @association_check_query
+    end
+
+    def associations
+      @associations ||= case matcher
+      when Regexp
+        table.reflect_on_all_associations(:belongs_to).select do |a|
+          a.foreign_key =~ matcher
+        end
+      else
+        [ table.reflect_on_association(matcher) ]
+      end
+    end
+
+    def positive?
+      @positive_query
+    end
+
+    def conditions?
+      @conditions_query
+    end
+
+    def unambiguous?
+      positive? and not matcher.is_a?(Regexp)
+    end
+  end
+end

data/lib/table_warnings/size.rb

@@ -0,0 +1,55 @@
+module TableWarnings
+  class Size
+    attr_reader :table
+    attr_reader :approximate_size
+    attr_reader :conditions
+
+    def initialize(table, approximate_size, options = {})
+      @table = table
+      @approximate_size = approximate_size
+      @conditions = options[:conditions] || {}
+    end
+    
+    def messages
+      current_count = effective_count
+      unless allowed_size.include? current_count
+        if conditions.empty?
+          "Table is not of expected size (expected: #{allowed_size.to_s}, actual: #{current_count})"
+        else
+          "Table count with conditions #{conditions.inspect} is not of expected size (expected: #{allowed_size.to_s}, actual: #{current_count})"
+        end
+      end
+    end
+
+    private
+
+    def effective_count
+      if conditions.empty?
+        table.count
+      else
+        table.where(conditions).count
+      end
+    end
+
+    def allowed_size
+      case approximate_size
+      when :few
+        1..10
+      when :dozens, :tens
+        10..100
+      when :hundreds
+        100..1_000
+      when :thousands
+        1_000..99_000
+      when :hundreds_of_thousands
+        100_000..1_000_000
+      when :millions
+        1_000_000..1_000_000_000
+      when Range
+        approximate_size
+      when Numeric
+        approximate_size..approximate_size
+      end
+    end
+  end
+end