passiverecord 0.0.1

data/History.txt

@@ -0,0 +1,6 @@
+== 0.0.1 2007-09-26
+
+* Initial release
+  * proof of concept
+  * create, find, find_by_*
+  * has_many, has_one

data/Manifest.txt

@@ -0,0 +1,12 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/passive_record.rb
+lib/passive_record/associations.rb
+lib/passive_record/base.rb
+lib/passive_record/schema.rb
+lib/passive_record/version.rb
+test/test_associations.rb
+test/test_base.rb
+test/test_helper.rb

data/README.txt

@@ -0,0 +1,79 @@
+= PassiveRecord
+by Jason L Perry (http://paint.itred.org)
+
+== DESCRIPTION:
+  
+A replacement for ActiveRecord when you just need to model
+a few unchanging objects, and don't necessarily need a full blown
+ActiveRecord class and table in the database.
+
+== FEATURES:
+  
+* some basic ActiveRecord style finders
+* dynamic attribute based finders, supporting basic comparisons as well
+  regular expressions and ranges
+* some integrated ActiveRecord associactions, ie: ActiveRecord#belongs_to(:passive_record)
+  PassiveRecord#has_many(:active_records) (excluding has_many :through)
+  
+== TODOs:
+
+* has_many :through
+* extend find options like :conditions, :order
+* find(:first) (depends on :order being implemented)
+* better documentation of the code
+* fix warnings in tests
+
+== SYNOPSIS:
+
+  class Continent < PassiveRecord::Base
+    has_many :countries # => an ActiveRecord class
+  
+    schema :name => String,          :size => Integer,  :population => Integer
+  
+    create :name => "Africa",        :size => 30370000, :population => 890000000 
+    create :name => "Antarctica",    :size => 13720000, :population => 1000
+    create :name => "Australia",     :size => 7600000,  :population => 20000000
+    create :name => "Eurasia",       :size => 53990000, :population => 4510000000
+    create :name => "North America", :size => 24490000, :population => 515000000
+    create :name => "South America", :size => 17840000, :population => 371000000
+  end
+
+  Continent.find(1)                                     # => Africa
+  Continent.find_by_name("Africa")                      # => Yes, also Africa
+  Continent.find_by_name_and_size(/America/, 17840000)  # => South America
+  Continent.find_all_by_population(1000..20000000)      # => Antarctica and Australia
+  Continent.find(:all)                                  # => All 6 (though not in any particular order, yet)
+
+== REQUIREMENTS:
+
+* activerecord
+
+== INSTALL:
+
+* gem install passiverecord
+* require "passive_record"
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 Jason L Perry (Paint.itRed)
+
+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,19 @@
+$:.unshift(File.dirname(__FILE__) + "/lib")
+require 'rubygems'
+require 'hoe'
+
+require 'passive_record/version'
+
+Hoe.new('passiverecord', PassiveRecord::VERSION::STRING) do |p|
+  p.rubyforge_name  = 'paintitred'
+  p.author          = 'Jason L Perry'
+  p.email           = 'jasper@ambethia.com'
+  p.summary         = 'Pacifying overactive records'
+  p.description     = 'Pacifying overactive records'
+  p.url             = "http://code.itred.org/projects/passive-record"
+  p.changes         = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.extra_deps      = [['activerecord', '>= 1.15.3']]
+  p.remote_rdoc_dir = "passive_record"
+end
+
+Hoe.send :define_method, :extra_deps, proc { @extra_deps.reject! { |x| Array(x).first == 'hoe' };@extra_deps}

data/lib/passive_record.rb

@@ -0,0 +1,17 @@
+$:.unshift(File.dirname(__FILE__))
+
+begin
+  require 'active_record'
+rescue LoadError => e
+  require 'rubygems'
+  require 'active_record'
+end
+
+require 'passive_record/base'
+require 'passive_record/schema'
+require 'passive_record/associations'
+
+PassiveRecord::Base.class_eval do
+  include PassiveRecord::Schema
+  include PassiveRecord::Associations
+end

data/lib/passive_record/associations.rb

@@ -0,0 +1,276 @@
+# Currently this is a big hack job of code from active record
+# TODO: Trim this down, and test it thoroughly
+module PassiveRecord
+  module Associations
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      ActiveRecord::Callbacks::CALLBACKS.each do |method|
+        base.class_eval <<-"end_eval"
+          def self.#{method}(*callbacks, &block)
+            callbacks << block if block_given?
+            write_inheritable_array(#{method.to_sym.inspect}, callbacks)
+          end
+        end_eval
+      end
+    end
+
+    def quoted_id #:nodoc:
+      ActiveRecord::Base.quote_value(self.key)
+    end
+    
+    def attribute_present?(attribute)
+      value = self.respond_to?(attribute) ? self.send(attribute) : nil
+      !value.blank? or value == 0
+    end
+    
+    def read_attribute(attribute)
+      self.send(attribute)
+    end
+    
+    def new_record?
+      false
+    end
+    
+    module ClassMethods
+
+      def has_many(association_id, options = {}, &extension)
+        reflection = create_has_many_reflection(association_id, options, &extension)
+
+        ActiveRecord::Base.send(:configure_dependency_for_has_many, reflection)
+
+        if options[:through]
+          collection_reader_method(reflection, ActiveRecord::Associations::HasManyThroughAssociation)
+        else
+          add_multiple_associated_save_callbacks(reflection.name)
+          add_association_callbacks(reflection.name, reflection.options)
+          collection_accessor_methods(reflection, ActiveRecord::Associations::HasManyAssociation)
+        end
+      end
+      
+      def has_one(association_id, options = {})
+        reflection = create_has_one_reflection(association_id, options)
+
+        module_eval do
+          after_save <<-EOF
+            association = instance_variable_get("@#{reflection.name}")
+            if !association.nil? && (new_record? || association.new_record? || association["#{reflection.primary_key_name}"] != id)
+              association["#{reflection.primary_key_name}"] = id
+              association.save(true)
+            end
+          EOF
+        end
+      
+        association_accessor_methods(reflection, ActiveRecord::Associations::HasOneAssociation)
+        association_constructor_method(:build,  reflection, ActiveRecord::Associations::HasOneAssociation)
+        association_constructor_method(:create, reflection, ActiveRecord::Associations::HasOneAssociation)
+        
+        ActiveRecord::Base.send(:configure_dependency_for_has_one, reflection)
+      end
+      
+      def create_has_many_reflection(association_id, options, &extension)
+        options.assert_valid_keys(
+          :class_name, :table_name, :foreign_key,
+          :exclusively_dependent, :dependent,
+          :select, :conditions, :include, :order, :group, :limit, :offset,
+          :as, :through, :source, :source_type,
+          :uniq,
+          :finder_sql, :counter_sql, 
+          :before_add, :after_add, :before_remove, :after_remove, 
+          :extend
+        )
+
+        options[:extend] = create_extension_module(association_id, extension) if block_given?
+
+        create_reflection(:has_many, association_id, options, self)
+      end
+
+      def create_has_one_reflection(association_id, options)
+        options.assert_valid_keys(
+          :class_name, :foreign_key, :remote, :conditions, :order, :include, :dependent, :counter_cache, :extend, :as
+        )
+
+        create_reflection(:has_one, association_id, options, self)
+      end
+
+      def create_reflection(macro, name, options, active_record)
+        case macro
+          when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
+            reflection = ActiveRecord::Reflection::AssociationReflection.new(macro, name, options, active_record)
+          when :composed_of
+            reflection = AggregateReflection.new(macro, name, options, active_record)
+        end
+        write_inheritable_hash :reflections, name => reflection
+        reflection
+      end
+            
+      def add_multiple_associated_save_callbacks(association_name)
+        method_name = "validate_associated_records_for_#{association_name}".to_sym
+        define_method(method_name) do
+          association = instance_variable_get("@#{association_name}")
+          if association.respond_to?(:loaded?)
+            if new_record?
+              association
+            else
+              association.select { |record| record.new_record? }
+            end.each do |record|
+              errors.add "#{association_name}" unless record.valid?
+            end
+          end
+        end
+
+        validate method_name
+        before_save("@new_record_before_save = new_record?; true")
+
+        after_callback = <<-end_eval
+          association = instance_variable_get("@#{association_name}")
+          
+          if association.respond_to?(:loaded?)
+            if @new_record_before_save
+              records_to_save = association
+            else
+              records_to_save = association.select { |record| record.new_record? }
+            end
+            records_to_save.each { |record| association.send(:insert_record, record) }
+            association.send(:construct_sql)   # reconstruct the SQL queries now that we know the owner's id
+          end
+        end_eval
+              
+        # Doesn't use after_save as that would save associations added in after_create/after_update twice
+        after_create(after_callback)
+        after_update(after_callback)
+      end
+
+      def add_association_callbacks(association_name, options)
+        callbacks = %w(before_add after_add before_remove after_remove)
+        callbacks.each do |callback_name|
+          full_callback_name = "#{callback_name}_for_#{association_name}"
+          defined_callbacks = options[callback_name.to_sym]
+          if options.has_key?(callback_name.to_sym)
+            class_inheritable_reader full_callback_name.to_sym
+            write_inheritable_array(full_callback_name.to_sym, [defined_callbacks].flatten)
+          end
+        end
+      end
+      
+      def collection_accessor_methods(reflection, association_proxy_class)
+        collection_reader_method(reflection, association_proxy_class)
+
+        define_method("#{reflection.name}=") do |new_value|
+          # Loads proxy class instance (defined in collection_reader_method) if not already loaded
+          association = send(reflection.name) 
+          association.replace(new_value)
+          association
+        end
+
+        define_method("#{reflection.name.to_s.singularize}_ids") do
+          send(reflection.name).map(&:id)
+        end
+
+        define_method("#{reflection.name.to_s.singularize}_ids=") do |new_value|
+          ids = (new_value || []).reject { |nid| nid.blank? }
+          send("#{reflection.name}=", reflection.class_name.constantize.find(ids))
+        end
+      end
+      
+      def collection_reader_method(reflection, association_proxy_class)
+        define_method(reflection.name) do |*params|
+          force_reload = params.first unless params.empty?
+          association = instance_variable_get("@#{reflection.name}")
+
+          unless association.respond_to?(:loaded?)
+            association = association_proxy_class.new(self, reflection)
+            instance_variable_set("@#{reflection.name}", association)
+          end
+
+          association.reload if force_reload
+
+          association
+        end
+      end
+      
+      def association_accessor_methods(reflection, association_proxy_class)
+        define_method(reflection.name) do |*params|
+          force_reload = params.first unless params.empty?
+          association = instance_variable_get("@#{reflection.name}")
+
+          if association.nil? || force_reload
+            association = association_proxy_class.new(self, reflection)
+            retval = association.reload
+            if retval.nil? and association_proxy_class == BelongsToAssociation
+              instance_variable_set("@#{reflection.name}", nil)
+              return nil
+            end
+            instance_variable_set("@#{reflection.name}", association)
+          end
+
+          association.target.nil? ? nil : association
+        end
+
+        define_method("#{reflection.name}=") do |new_value|
+          association = instance_variable_get("@#{reflection.name}")
+          if association.nil?
+            association = association_proxy_class.new(self, reflection)
+          end
+
+          association.replace(new_value)
+
+          unless new_value.nil?
+            instance_variable_set("@#{reflection.name}", association)
+          else
+            instance_variable_set("@#{reflection.name}", nil)
+            return nil
+          end
+
+          association
+        end
+
+        define_method("set_#{reflection.name}_target") do |target|
+          return if target.nil? and association_proxy_class == BelongsToAssociation
+          association = association_proxy_class.new(self, reflection)
+          association.target = target
+          instance_variable_set("@#{reflection.name}", association)
+        end
+      end
+
+      def association_constructor_method(constructor, reflection, association_proxy_class)
+        define_method("#{constructor}_#{reflection.name}") do |*params|
+          attributees      = params.first unless params.empty?
+          replace_existing = params[1].nil? ? true : params[1]
+          association      = instance_variable_get("@#{reflection.name}")
+
+          if association.nil?
+            association = association_proxy_class.new(self, reflection)
+            instance_variable_set("@#{reflection.name}", association)
+          end
+
+          if association_proxy_class == HasOneAssociation
+            association.send(constructor, attributees, replace_existing)
+          else
+            association.send(constructor, attributees)
+          end
+        end
+      end
+
+      def validate(*methods, &block)
+        methods << block if block_given?
+        write_inheritable_set(:validate, methods)
+      end
+
+      def write_inheritable_set(key, methods)
+        existing_methods = read_inheritable_attribute(key) || []
+        write_inheritable_attribute(key, methods | existing_methods)
+      end
+
+      def compute_type(*args)
+        ActiveRecord::Base.send(:compute_type, *args)
+      end
+      
+      def reflect_on_association(*args)
+        ActiveRecord::Base.send(:reflect_on_association, *args)
+      end
+      
+    end
+  end
+end

data/lib/passive_record/base.rb

@@ -0,0 +1,126 @@
+module PassiveRecord
+  class PassiveRecordError < StandardError; end
+  class RecordNotFound < PassiveRecordError; end
+
+  class Base
+    @@instances = {}
+
+    attr_accessor :attributes, :key
+
+    alias :id :key
+
+    def initialize(attributes = {})
+      @attributes = attributes
+      yield self if block_given?
+    end
+
+    def [](attribute_name)
+      self.attributes[attribute_name]
+    end
+
+    def []=(attribute_name, value)
+      self.attributes[attribute_name] = value
+    end
+
+    def ==(comparison_object)
+      comparison_object.equal?(self) ||
+        (comparison_object.instance_of?(self.class) && 
+          comparison_object.id == id && 
+          !comparison_object.new_record?)
+    end
+    
+
+    class << self
+
+      def create(*args)
+        attributes = extract_options!(args)
+        key = args.first || @@instances.size+1
+        instance = self.new(attributes)
+        instance.key = key
+        @@instances[key] = instance
+        return key
+      end
+
+      private :create
+
+      def find(*args)
+        options = extract_options!(args)
+        args.first == :all ? find_every : find_from_keys(args)
+      end
+
+      def count
+        find_every.size
+      end
+
+    protected
+
+      # def find_initial(options)
+      # end
+
+      def find_every
+        @@instances.select { |key, value| value.is_a?(self) }.map {|its| its.last}
+      end
+
+      def find_from_keys(keys, options = {})
+        
+        expects_array = keys.first.kind_of?(Array)
+        return keys.first if expects_array && keys.first.empty?
+        keys = keys.flatten.compact.uniq
+
+        case keys.size
+          when 0
+            raise RecordNotFound, "Couldn't find #{name} without a key"
+          when 1
+            result = find_one(keys.first)
+            expects_array ? [ result ] : result
+          else
+            find_some(keys)
+        end
+      end
+
+      def find_one(_key)
+        values = @@instances.select { |key, value| _key == key && value.is_a?(self) }.map {|its| its.last}
+        unless values.empty?
+          return values.first
+        else
+          raise RecordNotFound, "Couldn't find #{name} with the given key."
+        end
+      end
+
+      def find_some(keys)
+        values = @@instances.select { |key, value| (keys).include?(key) && value.is_a?(self) }.map {|its| its.last}
+      end
+
+      def extract_options!(args) #:nodoc:
+        args.last.is_a?(Hash) ? args.pop : {}
+      end
+      
+      # TODO: clean this mess up
+      def method_missing(method_id, *arguments)
+        if match = /^find_(all_by|by)_([_a-zA-Z]\w*)$/.match(method_id.to_s)
+          expects_array   = match.captures.first == 'all_by'
+          attribute_names = match.captures.last.split('_and_')
+          # super unless all_attributes_exists?(attribute_names)
+          attributes = {}
+          attribute_names.each_with_index { |name, idx| attributes[name] = arguments[idx] }
+          expressions = []
+          attributes.each_pair { |key, value| expressions << attribute_expression("value.#{key}", value)  }          
+          results = @@instances.select { |key, value| eval expressions.join(" && ")  }.map {|its| its.last}
+          return expects_array ? results : results.pop
+        else
+          super
+        end
+      end
+            
+      def attribute_expression(name, argument)
+        case argument
+        when Regexp then "#{name} =~ /#{argument}/"
+        when Range  then "(#{argument}).include?(#{name})"
+        when String then "#{name} == \"#{argument}\""
+        else             "#{name} == #{argument}"
+        end
+      end
+      
+    end
+  end
+end

data/lib/passive_record/schema.rb

@@ -0,0 +1,25 @@
+module PassiveRecord
+  module Schema
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      
+      # Define the schema for your model, this also adds attribute accessors for schema columns
+      def schema(definition = {})
+        @@schema = definition
+        definition.keys.each do |attribute_name|
+          define_method("#{attribute_name}") do
+            self[attribute_name]
+          end
+          define_method("#{attribute_name}=") do |new_value|
+            self[attribute_name] = new_value
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/passive_record/version.rb

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

data/test/test_associations.rb

@@ -0,0 +1,96 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class Room < PassiveRecord::Base
+  has_many :furniture, :order => :name
+  has_one  :light_fixture, :class_name => "Furniture"
+  
+  has_many :ins,   :class_name => "Door", :foreign_key => "outside_id"
+  has_many :outs,  :class_name => "Door", :foreign_key => "inside_id"
+  
+  has_many :exits, :through => :outs
+  has_many :entrances, :through => :ins
+  
+  schema :name => String
+  
+  create :name => "Family Room"
+  create :name => "Kitchen"
+  create :name => "Bedroom"
+  create :name => "Restroom"
+  create :name => "Office"
+end
+
+ActiveRecord::Base.establish_connection(:adapter  => "sqlite3", :database => ":memory:")
+ActiveRecord::Base.connection.create_table "furniture", :force => true do |t|
+  t.column :name,    :string
+  t.column :room_id, :integer
+end 
+
+ActiveRecord::Base.connection.create_table "doors", :force => true do |t|
+  t.column :inside_id,  :integer
+  t.column :outside_id, :integer
+end 
+
+Inflector.inflections { |inflect| inflect.uncountable %w( furniture )}
+
+class Furniture < ActiveRecord::Base
+  belongs_to :room
+end
+
+class Door < ActiveRecord::Base
+  belongs_to :inside,   :class_name => "Room", :foreign_key => "inside_id"
+  belongs_to :outside,  :class_name => "Room", :foreign_key => "outside_id"
+end
+
+class PassiveRecord::AssociationsTest < Test::Unit::TestCase
+
+  # some "fixtures"
+  def setup
+    Furniture.create :name => "Couch",    :room_id => Room.find_by_name("Family Room").id
+    Furniture.create :name => "Ottoman",  :room_id => Room.find_by_name("Family Room").id
+    Furniture.create :name => "Ott-lite", :room_id => Room.find_by_name("Office").id
+    
+    Door.create :inside_id  => Room.find_by_name("Office").id,
+                :outside_id => Room.find_by_name("Family Room").id
+                
+    Door.create :inside_id  => Room.find_by_name("Restroom").id,
+                :outside_id => Room.find_by_name("Family Room").id
+  end
+  
+  def test_should_have_many
+    furniture = [
+      Furniture.find_by_name("Couch"),
+      Furniture.find_by_name("Ottoman")
+    ]
+    room = Room.find_by_name("Family Room")
+    assert_equal furniture, room.furniture
+  end
+
+  def test_should_have_many_through
+    rooms = [
+      Room.find_by_name("Office"),
+      Room.find_by_name("Restroom")
+    ]
+    
+    room = Room.find_by_name("Family Room")
+    
+    # assert_equal room, room.exits
+  end
+
+  def test_should_have_one
+    lamp = Furniture.find_by_name("Ott-lite")
+    room = Room.find_by_name("Office")
+    assert_equal lamp, room.light_fixture
+  end
+  
+  def test_should_belong_to
+    lamp = Furniture.find_by_name("Ott-lite")
+    room = Room.find_by_name("Office")
+
+    assert_equal room, lamp.room    
+  end
+  
+  def teardown
+    Furniture.delete_all
+  end
+   
+end

data/test/test_base.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class Continent < PassiveRecord::Base
+  schema :name => String, :size => Integer, :population => Integer  
+end
+
+class PassiveRecord::BaseTest < Test::Unit::TestCase
+  
+  def setup
+    # Add the geographic 6 continents
+    Continent.send :create, :name => "Africa",        :size => 30370000, :population => 890000000 
+    Continent.send :create, :name => "Antarctica",    :size => 13720000, :population => 1000
+    Continent.send :create, :name => "Australia",     :size => 7600000,  :population => 20000000
+    Continent.send :create, :name => "Eurasia",       :size => 53990000, :population => 4510000000
+    Continent.send :create, :name => "North America", :size => 24490000, :population => 515000000
+    Continent.send :create, :name => "South America", :size => 17840000, :population => 371000000
+  end
+    
+  def test_should_create_instance
+    assert_equal 7, Continent.send(:create, :name => "Atlantis", :size => 0, :population => 0)
+  end
+  
+  def test_should_create_instance_with_manual_key
+    assert_equal "ATL", Continent.send(:create, "ATL", :name => "Atlantis", :size => 0, :population => 0)
+    assert Continent.find("ATL")
+  end
+  
+  def test_should_count_instances
+    assert_equal 6, Continent.count
+  end
+    
+  def test_should_find_one_by_key
+    assert Continent.find(1).is_a?(Continent)
+  end
+
+  def test_should_find_one_by_key_as_array
+    assert Continent.find([6]).is_a?(Array)
+  end
+
+  def test_should_find_some_by_key
+    assert_equal 2, Continent.find(1,2).size
+  end
+
+  def test_should_find_some_by_key_as_array
+    assert_equal 2, Continent.find([5,6]).size
+    assert_equal 2, Continent.find([5,6,7]).size
+  end
+  
+  def test_should_find_all
+    assert_equal 6, Continent.find(:all).size
+  end
+  
+  def test_should_get_attributes
+    assert_equal "Africa", Continent.find(1).name
+    assert_equal 1000,     Continent.find(2).population
+  end
+
+  def test_should_set_attributes
+    assert Continent.find(1).name = "Motherland"
+    assert_equal "Motherland", Continent.find(1).name
+  end
+  
+  def test_should_find_by_attribute
+    assert_equal Continent.find(1), Continent.find_by_name("Africa")
+    assert_equal Continent.find(5), Continent.find_by_population(515000000)
+  end
+  
+  def test_should_find_all_by_attribute_as_regex
+    assert_equal Continent.find(5,6), Continent.find_all_by_name(/America/)
+  end
+
+  def test_should_find_all_by_attribute_in_range
+    assert_equal Continent.find(2,3), Continent.find_all_by_population(1000..20000000)
+  end
+  
+  def test_should_find_by_many_attributes
+    assert_equal Continent.find(6), Continent.find_by_name_and_size(/America/, 17840000)
+  end
+
+  def test_should_puts_some_stuff
+  end
+  
+  def teardown
+    Continent.send :class_variable_set, "@@instances", {}
+  end
+   
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/passive_record'

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: passiverecord
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-09-26 00:00:00 -04:00
+summary: Pacifying overactive records
+require_paths: 
+- lib
+email: jasper@ambethia.com
+homepage: http://code.itred.org/projects/passive-record
+rubyforge_project: paintitred
+description: Pacifying overactive records
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Jason L Perry
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/passive_record.rb
+- lib/passive_record/associations.rb
+- lib/passive_record/base.rb
+- lib/passive_record/schema.rb
+- lib/passive_record/version.rb
+- test/test_associations.rb
+- test/test_base.rb
+- test/test_helper.rb
+test_files: 
+- test/test_associations.rb
+- test/test_base.rb
+- test/test_helper.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.15.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: