voraz-dr_nic_magic_models 0.9.2

data/lib/dr_nic_magic_models/schema.rb

@@ -0,0 +1,270 @@
+module DrNicMagicModels
+
+  # ONE Schema per namespace module
+  # Person, Company, etc share the Object namespace module, ie. ::Person, ::Company
+  # Blog::Post, Blog::Comment, share the Blog namespace module
+  class Schema
+    attr_reader :modul
+
+    def initialize(modul)
+      @modul = modul
+      @table_name_prefix = modul.instance_variable_get("@table_name_prefix") rescue ''
+      logger.info "Create Schema for #{@modul}, table_name_prefix '#{@table_name_prefix}'"
+    end
+
+    cattr_accessor :inflector
+    cattr_accessor :superklass
+
+    # Need to store models etc per-module, not in @ @models
+    def inflector
+      @inflector ||= Inflector.new
+    end
+
+    # all in lower case please
+    ReservedTables = [:schema_info, :sessions]
+    @models = nil
+
+    def logger
+      @logger ||= DrNicMagicModels::Logger
+    end
+
+    def models
+      load_schema if @models.nil?
+      @models
+    end
+
+    def tables
+      load_schema if @tables.nil?
+      @tables
+    end
+
+    def table_names
+      load_schema if @table_names.nil?
+      @table_names
+    end
+
+    def fks_on_table(table_name)
+      load_schema if @models.nil?
+      @fks_by_table[table_name.to_s] || []
+    end
+
+    # active record only support 2 column link tables, otherwise use a model table, has_many and through
+    def is_link_table?(table_name)
+      load_schema if @models.nil?
+      return @link_tables[table_name] if ! @link_tables[table_name].nil?
+      column_names = @conn.columns(table_name).map{|x| x.name }
+      @link_tables[table_name] = ! column_names.include?("id") && column_names.length == 2 && column_names.select { |x| x =~ /_id$/ } == column_names
+      return @link_tables[table_name]
+    end
+
+    def link_tables_for_class(klass)
+      load_schema if @models.nil?
+    end
+
+    def load_schema(preload = false)
+      return if !@models.nil?
+
+      @superklass ||= ActiveRecord::Base
+      raise "No database connection" if !(@conn = @superklass.connection)
+
+      @models = ModelHash.new
+      @tables = Hash.new
+      @fks_by_table = Hash.new
+      @link_tables = Hash.new
+
+      @table_names = @conn.tables
+      @table_names = @table_names.grep(/^#{@table_name_prefix}/) if @table_name_prefix
+      @table_names = @table_names.sort
+
+      logger.info "For #{modul} tables are #{@table_names.inspect}"
+
+      # Work out which tables are in the model and which aren't
+      @table_names.each do |table_name|
+
+        # deal with reserved tables & link_tables && other stray id-less tables
+        #key = 'id'
+        #case ActiveRecord::Base.primary_key_prefix_type
+        #  when :table_name
+        #    key = Inflector.foreign_key(table_name, false)
+        #  when :table_name_with_underscore
+        #    key = Inflector.foreign_key(table_name)
+        #end
+        #next if ReservedTables.include?(table_name.downcase.to_sym) ||
+        #        is_link_table?(table_name) ||
+        #        ! @conn.columns(table_name).map{ |x| x.name}.include?(key)
+
+        table_name_clean = table_name.gsub(/^#{@table_name_prefix}/,'')
+
+        # a model table then...
+        model_class_name = inflector.class_name(table_name_clean)
+
+        logger.debug "Got a model table: #{table_name} => class #{model_class_name}"
+
+        @models[model_class_name] = table_name
+        @tables[table_name] = model_class_name
+
+        if preload
+          # create by MAGIC!
+          klass = model_class_name.constantize
+
+          # Process FKs?
+          if @conn.supports_fetch_foreign_keys?
+
+            tables.each do |table_name|
+              logger.debug "Getting FKs for #{table_name}"
+              @fks_by_table[table_name] = Array.new
+              @conn.foreign_key_constraints(table_name).each do |fk|
+                logger.debug "Got one: #{fk}"
+                @fks_by_table[table_name].push(fk)
+              end # do each fk
+
+            end # each table
+          end
+
+          # Try to work out our link tables now...
+          @models.keys.sort.each{|klass| process_table(@models[klass.to_s])}
+          @link_tables.keys.sort.each{|table_name| process_link_table(table_name) if @link_tables[table_name]}
+        end
+      end
+
+    end
+
+    def process_table(table_name)
+
+      logger.debug "Processing model table #{table_name}"
+
+      # ok, so let's look at the foreign keys on the table...
+      belongs_to_klass = @tables[table_name].constantize rescue return
+
+      processed_columns = Hash.new
+
+      fks_on_table(table_name).each do |fk|
+        logger.debug "Found FK column by suffix _id [#{fk.foreign_key}]"
+        has_some_klass = Inflector.classify(fk.reference_table).constantize rescue next
+      processed_columns[fk.foreign_key] = { :has_some_klass => has_some_klass }
+        processed_columns[fk.foreign_key].merge! add_has_some_belongs_to(belongs_to_klass, fk.foreign_key, has_some_klass) rescue next
+      end
+
+      column_names = @conn.columns(table_name).map{ |x| x.name}
+      column_names.each do |column_name|
+        next if not column_name =~ /_id$/
+        logger.debug "Found FK column by suffix _id [#{column_name}]"
+        if processed_columns.key?(column_name)
+          logger.debug "Skipping, already processed"
+          next
+        end
+        has_some_klass = Inflector.classify(column_name.sub(/_id$/,"")).constantize rescue next
+      processed_columns[column_name] = { :has_some_klass => has_some_klass }
+        processed_columns[column_name].merge! add_has_some_belongs_to(belongs_to_klass, column_name, has_some_klass) rescue next
+      end
+
+      #TODO: what if same classes in table?
+
+      # is this a link table with attributes? (has_many through?)
+      return if processed_columns.keys.length < 2
+
+      processed_columns.keys.each do |key1|
+        processed_columns.keys.each do |key2|
+          next if key1 == key2
+          logger.debug "\n*** #{processed_columns[key1][:has_some_class]}.send 'has_many', #{processed_columns[key2][:belongs_to_name].to_s.pluralize.to_sym}, :through => #{processed_columns[key2][:has_some_name]}\n\n"
+          processed_columns[key1][:has_some_class].send 'has_many', processed_columns[key2][:belongs_to_name].to_s.pluralize.to_sym, :through => processed_columns[key2][:has_some_name].to_sym
+        end
+      end
+
+    end
+
+    def add_has_some_belongs_to(belongs_to_klass, belongs_to_fk, has_some_klass)
+
+      logger.debug "Trying to add a #{belongs_to_klass} belongs_to #{has_some_klass}..."
+
+      # so this is a belongs_to & has_some style relationship...
+      # is it a has_many, or a has_one? Well, let's assume a has_one has a unique index on the column please... good db design, haha!
+      unique = belongs_to_klass.get_unique_index_columns.include?(belongs_to_fk)
+      belongs_to_name = belongs_to_fk.sub(/_id$/, '').to_sym
+
+      logger.debug "\n*** #{belongs_to_klass}.send 'belongs_to', #{belongs_to_name}, :class_name => #{has_some_klass}, :foreign_key => #{belongs_to_fk}\n"
+      belongs_to_klass.send(:belongs_to, belongs_to_name, :class_name => has_some_klass.to_s, :foreign_key => belongs_to_fk.to_sym)
+
+      # work out if we need a prefix
+      has_some_name = (
+       (unique ? belongs_to_klass.table_name.singularize : belongs_to_klass.table_name) +
+       (belongs_to_name.to_s == has_some_klass.table_name.singularize ? "" : "_as_"+belongs_to_name.to_s)
+      ).downcase.to_sym
+      method = unique ? :has_one : :has_many
+      logger.debug "\n*** #{has_some_klass}.send(#{method}, #{has_some_name}, :class_name => #{belongs_to_klass.to_s}, :foreign_key => #{belongs_to_fk.to_sym})\n\n"
+      has_some_klass.send(method, has_some_name, :class_name => belongs_to_klass.to_s, :foreign_key => belongs_to_fk.to_sym)
+
+      return { :method => method, :belongs_to_name => belongs_to_name, :has_some_name => has_some_name, :has_some_class => has_some_klass  }
+
+    end
+
+    def process_link_table(table_name)
+
+      logger.debug "Processing link table #{table_name}"
+
+      classes_map = Hash.new
+      column_names = @conn.columns(table_name).map{ |x| x.name}
+
+      # use foreign keys first
+      fks_on_table(table_name).each do |fk|
+        logger.debug "Processing fk: #{fk}"
+        klass = Inflector.classify(fk.reference_table).constantize rescue logger.debug("Cannot find model #{class_name} for table #{fk.reference_table}") && return
+        classes_map[fk.foreign_key] = klass
+      end
+
+      logger.debug "Got #{classes_map.keys.length} references from FKs"
+
+      if classes_map.keys.length < 2
+
+        #Fall back on good ol _id recognition
+
+        column_names.each do |column_name|
+
+          # check we haven't processed by fks already
+          next if ! classes_map[column_name].nil?
+          referenced_table = column_name.sub(/_id$/, '')
+
+          begin
+            klass = Inflector.classify(referenced_table).constantize
+            # fall back on FKs here
+            if ! klass.nil?
+              classes_map[column_name] = klass
+            end
+          rescue
+          end
+        end
+      end
+
+      # not detected the link table?
+      logger.debug "Got #{classes_map.keys.length} references"
+      logger.debug "Cannot detect both tables referenced in link table" && return if classes_map.keys.length != 2
+
+      logger.debug "Adding habtm relationship"
+
+      logger.debug "\n*** #{classes_map[column_names[0]]}.send 'has_and_belongs_to_many', #{column_names[1].sub(/_id$/,'').pluralize.to_sym}, :class_name => #{classes_map[column_names[1]].to_s}, :join_table => #{table_name.to_sym}\n"
+      logger.debug "\n*** #{classes_map[column_names[1]]}.send 'has_and_belongs_to_many', #{column_names[0].sub(/_id$/,'').pluralize.to_sym}, :class_name => #{classes_map[column_names[0]].to_s}, :join_table => #{table_name.to_sym}\n\n"
+
+      classes_map[column_names[0]].send 'has_and_belongs_to_many', column_names[1].sub(/_id$/,'').pluralize.to_sym, :class_name => classes_map[column_names[1]].to_s, :join_table => table_name.to_sym
+      classes_map[column_names[1]].send 'has_and_belongs_to_many', column_names[0].sub(/_id$/,'').pluralize.to_sym, :class_name => classes_map[column_names[0]].to_s, :join_table => table_name.to_sym
+
+    end
+  end
+
+  class ModelHash < Hash
+    def unenquire(class_id)
+      @enquired ||= {}
+      @enquired[class_id = class_id.to_s] = false
+    end
+
+    def enquired?(class_id)
+      @enquired ||= {}
+      @enquired[class_id.to_s]
+    end
+
+    def [](class_id)
+      enquired?(class_id = class_id.to_s)
+      @enquired[class_id] = true
+      super(class_id)
+    end
+  end
+end

data/lib/dr_nic_magic_models/validations.rb

@@ -0,0 +1,46 @@
+module DrNicMagicModels
+  module Validations
+
+    def generate_validations
+
+      logger = DrNicMagicModels::Logger
+
+      # Ensure that the connection to db is established, else validations don't get created.
+      ActiveRecord::Base.connection
+      
+      # Code reworked from http://www.redhillconsulting.com.au/rails_plugins.html
+      # Thanks Red Hill Consulting for using an MIT licence :o)
+
+      # NOT NULL constraints
+      self.columns.reject { |column| column.name =~ /(?i)^(((created|updated)_(at|on))|position|type|id)$/ }.each do |column|
+        
+        if column.type == :integer   
+          logger.debug "validates_numericality_of #{column.name}, :allow_nil => #{column.null.inspect}, :only_integer => true"       
+          self.validates_numericality_of column.name, :allow_nil => column.null, :only_integer => true
+        elsif column.number?
+          logger.debug "validates_numericality_of #{column.name}, :allow_nil => #{column.null.inspect}"
+          self.validates_numericality_of column.name, :allow_nil => column.null
+        elsif column.text? && column.limit
+          logger.debug "validates_length_of #{column.name}, :allow_nil => #{column.null.inspect}, :maximum => #{column.limit}"
+          self.validates_length_of column.name, :allow_nil => column.null, :maximum => column.limit
+        end
+        
+        # Active record seems to interpolate booleans anyway to either true, false or nil...
+        if column.type == :boolean
+          logger.debug "validates_inclusion_of #{column.name}, :in => [true, false], :allow_nil => #{column.null}, :message => ActiveRecord::Errors.default_error_messages[:blank]"
+          self.validates_inclusion_of column.name, :in => [true, false], :allow_nil => column.null, :message => ActiveRecord::Errors.default_error_messages[:blank]
+        elsif !column.null
+          logger.debug "validates_presence_of #{column.name}"
+          self.validates_presence_of column.name
+        end
+      end
+      
+      # Single-column UNIQUE indexes
+      get_unique_index_columns.each do |col|
+        logger.debug "validates_uniqueness_of #{col}"
+        self.validates_uniqueness_of col, :allow_nil=>true, :allow_blank=>true
+      end                  
+
+    end    
+  end
+end

data/lib/dr_nic_magic_models/version.rb

@@ -0,0 +1,9 @@
+module DrNicMagicModels #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 9
+    TINY  = 2
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/dr_nic_magic_models.rb

@@ -0,0 +1,34 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+unless defined?(ActiveRecord)
+  begin
+    require 'active_record'  
+  rescue LoadError
+    require 'rubygems'
+    require_gem 'activerecord'
+  end
+end
+
+module DrNicMagicModels
+    Logger = RAILS_DEFAULT_LOGGER rescue Logger.new(STDERR)
+end
+
+require 'dr_nic_magic_models/magic_model'
+require 'dr_nic_magic_models/schema'
+require 'dr_nic_magic_models/validations'
+require 'dr_nic_magic_models/inflector'
+require 'base'
+require 'module'
+require 'rails' rescue nil
+require 'connection_adapters/abstract_adapter'
+require 'connection_adapters/mysql_adapter'
+require 'connection_adapters/postgresql_adapter'
+
+# load the schema
+# TODO - add this to README - DrNicMagicModels::Schema.load_schema(true)
+
+class ActiveRecord::Base
+  include DrNicMagicModels::MagicModel
+  extend DrNicMagicModels::Validations
+end

data/lib/module.rb

@@ -0,0 +1,33 @@
+class Module
+  alias :normal_const_missing :const_missing
+
+  def const_missing(class_id)
+    begin
+      return normal_const_missing(class_id)
+    rescue
+    end
+    @magic_schema ||= DrNicMagicModels::Schema.new self
+    unless table_name = @magic_schema.models[class_id]
+      raise NameError.new("uninitialized constant #{class_id}") if @magic_schema.models.enquired? class_id
+    end
+    superklass = @magic_schema.superklass || ActiveRecord::Base
+    klass = create_class(class_id, superklass) do
+      set_table_name table_name
+      # include DrNicMagicModels::MagicModel
+      # extend DrNicMagicModels::Validations
+    end
+    klass.generate_validations # need to call this AFTER the class name has been assigned
+    @magic_schema.inflector.post_class_creation klass
+    klass
+  end
+
+  def magic_module(options)
+    self.instance_variable_set "@table_name_prefix", options[:table_name_prefix] if options[:table_name_prefix]
+  end
+
+  private
+  def create_class(class_name, superclass, &block)
+    klass = Class.new superclass, &block
+    self.const_set class_name, klass
+  end
+end

data/lib/rails.rb

@@ -0,0 +1,19 @@
+module Dependencies #:nodoc:#
+
+  @@models_dir = File.expand_path(File.join(RAILS_ROOT,'app','models'))
+
+  # don't reload models... it doesn't work anyway, not sure why they haven't done this?
+  # submit as patch?
+  alias require_or_load_old require_or_load
+  def require_or_load(file_name, *args)
+    file_name = $1 if file_name =~ /^(.*)\.rb$/
+    expanded = File.expand_path(file_name)
+    old_mechanism = Dependencies.mechanism
+    if expanded =~ /^#{@@models_dir}/
+      RAILS_DEFAULT_LOGGER.debug "*** Not reloading #{file_name}"
+      Dependencies.mechanism = :require
+    end
+    require_or_load_old(file_name, *args)
+    Dependencies.mechanism = old_mechanism
+  end
+end

data/scripts/txt2html

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/dr_nic_magic_models/version.rb'
+
+version  = DrNicMagicModels::VERSION::STRING
+download = 'http://rubyforge.org/projects/magicmodels'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.dirname(__FILE__) + '/../website/template.rhtml'
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class=\"syntax\">#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)

data/scripts/txt2js

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require 'active_support'
+require File.dirname(__FILE__) + '/../lib/dr_nic_magic_models/version.rb'
+
+version  = DrNicMagicModels::VERSION::STRING
+download = 'http://rubyforge.org/projects/magicmodels'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.dirname(__FILE__) + '/../website/template.js'
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body = fsrc.read
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)

data/test/abstract_unit.rb

@@ -0,0 +1,70 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'test/unit'
+require 'active_record'
+require 'active_record/fixtures'
+require 'connection'
+require 'dr_nic_magic_models'
+
+ActiveSupport::Deprecation.debug = true
+
+
+QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type') unless Object.const_defined?(:QUOTED_TYPE)
+
+class Test::Unit::TestCase #:nodoc:
+  self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+  self.use_instantiated_fixtures = false
+  self.use_transactional_fixtures = true #(ENV['AR_NO_TX_FIXTURES'] != "yes")
+
+  def create_fixtures(*table_names, &block)
+    Fixtures.create_fixtures(File.dirname(__FILE__) + "/fixtures/", table_names, {}, &block)
+  end
+  
+  def assert_date_from_db(expected, actual, message = nil)
+    # SQL Server doesn't have a separate column type just for dates, 
+    # so the time is in the string and incorrectly formatted
+    if current_adapter?(:SQLServerAdapter)
+      assert_equal expected.strftime("%Y/%m/%d 00:00:00"), actual.strftime("%Y/%m/%d 00:00:00")
+    elsif current_adapter?(:SybaseAdapter)
+      assert_equal expected.to_s, actual.to_date.to_s, message
+    else
+      assert_equal expected.to_s, actual.to_s, message
+    end
+  end
+
+  def assert_queries(num = 1)
+    ActiveRecord::Base.connection.class.class_eval do
+      self.query_count = 0
+      alias_method :execute, :execute_with_query_counting
+    end
+    yield
+  ensure
+    ActiveRecord::Base.connection.class.class_eval do
+      alias_method :execute, :execute_without_query_counting
+    end
+    assert_equal num, ActiveRecord::Base.connection.query_count, "#{ActiveRecord::Base.connection.query_count} instead of #{num} queries were executed."
+  end
+
+  def assert_no_queries(&block)
+    assert_queries(0, &block)
+  end
+  
+end
+
+def current_adapter?(type)
+  ActiveRecord::ConnectionAdapters.const_defined?(type) &&
+    ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters.const_get(type))
+end
+
+ActiveRecord::Base.connection.class.class_eval do
+  cattr_accessor :query_count
+  alias_method :execute_without_query_counting, :execute
+  def execute_with_query_counting(sql, name = nil)
+    self.query_count += 1
+    execute_without_query_counting(sql, name)
+  end
+end
+
+#ActiveRecord::Base.logger = Logger.new(STDOUT)
+#ActiveRecord::Base.colorize_logging = false

data/test/connections/native_mysql/connection.rb

@@ -0,0 +1,14 @@
+print "Using native MySQL\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+db1 = "dr_nic_magic_models_unittest"
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => "mysql",
+  :username => "root",
+  :password => "",
+  :encoding => "utf8",
+  :database => db1
+)

data/test/connections/native_postgresql/connection.rb

@@ -0,0 +1,12 @@
+print "Using Postgres\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+db1 = "dr_nic_magic_models_unittest"
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => "postgresql",
+  :encoding => "utf8",
+  :database => db1
+)

data/test/connections/native_sqlite/connection.rb

@@ -0,0 +1,10 @@
+print "Using native Sqlite3\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => "sqlite3",
+  :dbfile   => "test.db"
+)
+

data/test/dummy_test.rb

@@ -0,0 +1,13 @@
+require 'abstract_unit'
+#require 'fixtures/user'
+#require 'fixtures/group'
+#require 'fixtures/membership'
+
+class DummyTest < Test::Unit::TestCase
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

data/test/env_test.rb

@@ -0,0 +1,10 @@
+require 'abstract_unit'
+
+class EnvTest < Test::Unit::TestCase
+
+  def test_modules
+    assert_not_nil DrNicMagicModels
+    assert_not_nil DrNicMagicModels::Validations
+    assert_not_nil DrNicMagicModels::Schema
+  end
+end

data/test/fixtures/adjectives.yml

@@ -0,0 +1,3 @@
+first:
+  id: 1
+  name: kind