datts_right 0.0.1

data/lib/datts_right.rb

@@ -0,0 +1,98 @@
+require 'datts_right/instance_methods'
+require 'datts_right/datt'
+#require 'datts_right/query_methods'
+#require 'datts_right/exceptions'
+
+module DattsRight
+  def has_datts(options={})
+    include DattsRight::InstanceMethods
+    #include DattsRight::QueryMethods
+    #ActiveRecord::QueryMethods.extend DattsRight::QueryMethods
+    #include DattsRight::Exceptions
+
+    cattr_accessor :datts_options
+    self.datts_options = options
+
+    has_many :datts, :as => :attributable, :dependent => :destroy
+
+    # Carry out delayed actions before save
+    before_save :build_dynamic_attributes
+
+    # scope :scope_self when looking through attributes so we don't look through all datts
+    # Why? What if you have Friend and Page models. 
+    #   * Some Phone records have a datt :price
+    #   * Some Page records have a datt :price
+    #
+    #   When we do Page.find_by_price(400) we want to search only the datts that belong to Page
+    #     and we want to disregard the rest of the datts.
+    scope :scope_self, lambda { joins(:datts).where("datts.attributable_type = :klass", :klass => self.name) }
+    scope :dattr_key, lambda { |attr_key| scope_self.joins(:datts).where("datts.attr_key = :attr_key", :attr_key => attr_key)}
+    scope :dattr_type, lambda { |object_type| scope_self.joins(:datts).where("object_type = :object_type", :object_type => object_type) }
+
+    scope :order_datt, lambda { |attr_key_with_order, object_type|
+      # possible attr_key_with_order forms: "field_name", "field_name ASC", "field_name DESC"
+      split_attr_key_with_order = attr_key_with_order.split(" ")
+      attr_key = split_attr_key_with_order.first
+      order_by = split_attr_key_with_order.last if split_attr_key_with_order.size > 1
+      order_value = "datts.#{object_type}_value"
+      order_value << " #{order_by}" if order_by
+      scope_self.dattr_key(attr_key).joins(:datts).dattr_type(object_type).order(order_value)
+    }
+    
+    scope :where_datt, lambda { |opts|
+      # TODO accept stuff other than the normal hash
+      # Lifted from AR::Relation#build_where
+      attributes = case opts
+      when String, Array
+        self.expand_hash_conditions_for_aggregates(opts)
+      when Hash
+        opts
+      end
+      results = self#joins(:datts)
+      # Look for all DattsRight records whose:
+      #   1. Has all dynamic_attributes
+      #   2. Those dynamic attributes match there conditions
+      attributes.each do |k, v|
+        conditions = "exists (" +
+          "select 1 from datts datt where " +
+          # restricting the attributable_id to pages.id forces all the exists clauses to reference a single attributable record. Layman's terms, assuming Page uses datts_right:
+          # find only pages that has the matching dynamic attributes
+          "#{self.table_name}.id = datt.attributable_id " +
+          "and datt.attributable_type = :attributable_type " +
+          "and datt.name = :name and datt.#{Datt.attr_column(v)} = :value" +
+        ")"
+        results = results.where(conditions, :attributable_type => self.name, :name => k.to_s, :value => v)
+      end
+      results
+    }
+
+    def self.method_missing(method_id, *arguments)
+      # TODO better way to hook this into the rails code, and not define my own
+      if method_id.to_s =~ /^find_(all_|last_)?by_([_a-zA-Z]\w*)$/
+        attributes = $2.split("_and_")
+        #puts "Will find by #{attributes.inspect}"
+        arg = arguments.first
+        scope_self.joins(:datts).where("datts.#{Datt.attr_column(arg)} = :value", :value => arg)
+      end
+    end
+
+    # Override AR::Base#respond_to? so we can return the matchers even if the
+    # attribute doesn't exist in the actual columns. Is this expensive?
+    def respond_to?(method_id, include_private=false)
+      # TODO perhaps we could save a cache somewhere of all methods used by
+      # any of the records of this class. that way, we can make this method
+      # act a bit more like AR::Base#respond_to?
+      #   Ex:
+      #     return true if all_attributes_exists?(match.attribute_names) || all_dynamic_attributes_exists?(match.attribute_names)
+      if match = ActiveRecord::DynamicFinderMatch.match(method_id)
+        return true
+      elsif match = ActiveRecord::DynamicScopeMatch.match(method_id)
+        return true
+      end
+
+      super
+    end
+  end
+end
+
+ActiveRecord::Base.extend DattsRight

data/lib/datts_right/datt.rb

@@ -0,0 +1,40 @@
+class Datt < ActiveRecord::Base
+  # TODO
+  # Set table name from configuration
+  belongs_to :attributable, :polymorphic => true
+
+  def value
+    send("#{object_type}_value")
+  end
+
+  def value=(v)
+    object_type = self.class.attr_type?(v)
+
+    # only allow object_type changes if this is NOT a new record
+    # and it's text to string or vice versa
+    interchangeable_types = %w(text string)
+    #puts "It's currently a #{self.object_type}, and we wanna make it a #{object_type}"
+    if !new_record? && interchangeable_types.include?(self.object_type) && interchangeable_types.include?(object_type) && self.object_type != object_type
+      #puts "It's not new, and we're setting it to #{object_type}"
+      self.object_type = object_type
+    end
+    send("#{self.class.attr_column(v)}=", v)
+  end
+
+  def self.attr_type?(v)
+    object_type = if v.is_a?(Integer)
+      "integer"
+    elsif v.is_a?(Float)
+      "float"
+    elsif v.is_a?(TrueClass) || v.is_a?(FalseClass)
+      "boolean"
+    elsif v.is_a?(String)
+      v.size < 255 ? "string" : "text"
+    end
+  end
+
+  # Returns what column this kind of data should be in
+  def self.attr_column(v)
+    "#{self.attr_type?(v)}_value"
+  end
+end

data/lib/datts_right/exceptions.rb

@@ -0,0 +1,10 @@
+module DattsRight
+  module Exceptions
+    class AttributeExistsError < StandardError
+      attr_reader :reason
+      def initialize(reason)
+        @reason = reason
+      end
+    end
+  end
+end

data/lib/datts_right/instance_methods.rb

@@ -0,0 +1,214 @@
+module DattsRight
+  module InstanceMethods
+    def add_dynamic_attribute(name, klass)
+      unless attributes.keys.include?(name.to_s)
+        name = name.to_s
+        datt = datts.find_by_attr_key(name.underscore)
+        unless datt
+          datt = datts.create :name => name, :attr_key => name.underscore, :object_type => klass
+          dynamic_columns(true)
+        end
+        #puts "Just added #{name} to #{self.class.name}##{id}, and here are the dynamic_attributes: #{dynamic_columns}"
+        datt
+      else
+        false
+      end
+    end
+
+    def remove_dynamic_attribute(name)
+      name = name.to_s
+      datt = datts.find_by_attr_key(name)
+      if datt
+        datt.destroy
+        dynamic_columns(true)
+      end
+    end
+
+    # Works like ActiveRecord's attributes except it returns dynamic attributes only
+    def dynamic_attributes(reload=false)
+      @dynamic_attributes ||= {}
+      return @dynamic_attributes if !reload
+      #puts "Reloading dynamic_attributes"
+      datts.each do |datt|
+        #puts "Adding this to @dynamic_attributes: #{datt.attr_key} => #{datt.value}"
+        @dynamic_attributes.merge({datt.attr_key => datt.value}) 
+      end
+      #puts "Here are teh datts: #{datts.inspect}, and this is what we're returning: #{@dynamic_attributes}"
+      @dynamic_attributes.symbolize_keys!
+    end
+
+    # Because we cannot determine the difference between the inexistence
+    # between key value pair point to nil (eg :hi => nil) and
+    # the key not existing, we need to have a different method to return
+    # information about the record in this format:
+    #   {:price => {:object_type => "integer", :value => 200}}
+    def dynamic_columns(reload=false)
+      @dynamic_columns ||= {}
+      @dynamic_columns if !reload
+      #puts "Building the dynamic_columns cache, and we'll look through #{datts.count} datts"
+      @dynamic_columns={}
+      datts.reload
+      datts.each do |datt|
+        #puts "Going through datt##{datt.id}"
+        dynamic_column = {
+          datt.attr_key.to_sym => {
+            :object_type => datt.object_type,
+            :value => datt.value
+          }
+        }
+        #puts "Added #{dynamic_column} to the dynamic columns"
+        @dynamic_columns.merge!(dynamic_column)
+      end
+      #puts "in dynamic_columns, returning: #{@dynamic_columns.inspect}"
+      @dynamic_columns
+    end
+
+    # Determines if the given attribute is a dynamic attribute.
+    def dynamic_attribute?(attr)
+      #puts "in dynamic_attribute?(:#{attr}). datts: #{datts.inspect}. Datt: #{Datt.all.inspect}"
+      #dynamic_columns.include?(attr.to_s)
+      !dynamic_columns[attr.to_sym].nil?
+      #return dynamic_attributes.include?(attr.to_sym) unless dynamic_attributes.empty?
+      #return false if self.class.column_names.include?(attr.to_s)
+      #false
+    end
+
+    # This overrides the attributes= defined in ActiveRecord::Base
+    # The only difference is that this doesn't check to see if the
+    # model responds_to the method before sending it
+    #def attributes=(new_attributes, guard_protected_attributes = true)
+      #return unless new_attributes.is_a?(Hash)
+      #attributes = new_attributes.stringify_keys
+
+      #multi_parameter_attributes = []
+      #attributes = sanitize_for_mass_assignment(attributes) if guard_protected_attributes
+
+      #attributes.each do |k, v|
+        #if k.include?("(")
+          #multi_parameter_attributes << [ k, v ]
+        #else
+          #send("#{k}=", v)
+        #end
+      #end
+
+      #assign_multiparameter_attributes(multi_parameter_attributes)
+    #end
+
+    # Overrides AR::Persistence#update_attributes
+    # Needed to change it because the AR::Persistence method updated the attributes
+    # method directly.
+    #   Ex.
+    #     self.attributes = attributes
+    #
+    # That won't work because our dynamic attributes aren't in the attributes field
+    def update_attributes(attributes)
+      # The following transaction covers any possible database side-effects of the
+      # attributes assignment. For example, setting the IDs of a child collection.
+      with_transaction_returning_status do
+        attributes.each do |k, v|
+          self.send("#{k}=", v)
+        end
+        save
+      end
+    end
+
+    # Overrides AR::Persistence#update_attributes!
+    # See DattsRight#update_attributes for the reason why
+    def update_attributes!(attributes)
+      with_transaction_returning_status do
+        attributes.each do |k, v|
+          self.send("#{k}=", v)
+        end
+        save!
+      end
+    end
+
+    private
+
+    # Called after validation on update so that dynamic attributes behave
+    # like normal attributes in the fact that the database is not touched
+    # until save is called.
+    def build_dynamic_attributes
+      return if @save_dynamic_attr.nil?
+      # This originally saves things into the "datts" column.
+      #write_attribute_without_dynamic_attributes "datts", @save_dynamic_attr
+      # We save things into the datts table
+      @save_dynamic_attr.each do |k, v|
+        k = k.to_s
+        datt = datts.find_by_attr_key(k)
+        #puts "to create or to update #{k}?"
+        if datt
+          datt.update_attribute(:value, v)
+          #puts "updated: #{datt.inspect}"
+        #else
+          #datt = datts.create! :name => k, :attr_key => k, :value => v
+          #puts "created: #{datt.inspect} among these datts: #{datts.inspect}"
+        end
+      end
+      @save_dynamic_attr = {}
+      true
+    end
+
+    # Implements dynamic-attributes as if real getter/setter methods
+    # were defined.
+    def method_missing(method_id, *args, &block)
+      #puts "in method_missing_without_dynamic_attributes. Checking #{method_id}"
+      begin
+        super method_id, *args, &block
+      rescue NoMethodError => e
+        attr_name = method_id.to_s.sub(/\=$/, '')
+        #puts "Now we check to see if price is a dynamic attribute. dynamic_columns: #{dynamic_columns}. is #{attr_name} in those dynamic_columns? #{dynamic_attribute?(attr_name)}"
+        if dynamic_attribute?(attr_name)
+          #puts "== And #{method_id} is a dynamic method"
+          if method_id.to_s =~ /\=$/
+            return write_attribute(attr_name, args[0])
+          else
+            return read_attribute(attr_name)
+          end
+        end
+        raise e
+      end
+    end
+
+    # Overrides AR::Base#read_attribute
+    def read_attribute(attr_name)
+      attr_name = attr_name.to_s
+      if dynamic_attribute?(attr_name)
+        #puts "trying to read datt #{attr_name}"
+        # If value is in the @save_dynamic_attr cache, and it's not blank
+        if !@save_dynamic_attr.blank? and @save_dynamic_attr[attr_name]
+          #puts "datt #{attr_name} IS in cache, so let's return its value"
+          # Then we return the value
+          return @save_dynamic_attr[attr_name]
+        else # The value is not there, or it's blank
+          #puts "datt #{attr_name} is NOT in cache, so let's load it from the datt table"
+          #attrs = read_attribute_without_dynamic_attributes(dynamic_attributes_options[:column_name].to_s)
+          #puts "Here are ALL the datts: #{Datt.all.inspect} and my id is: #{id}"
+          #puts "Here are my the datts: #{datts.inspect} and my id is: #{id}. and the first datt's value is #{datts.first.value}"
+          datt = datts.find_by_attr_key(attr_name)
+          #puts "This is the dat I find: #{datt.inspect}"
+          return datt.try(:value)
+          #attrs = attrs.nil? ? nil : YAML.load(attrs).symbolize_keys! unless attrs.is_a? Hash
+          #return nil if attrs.blank?
+          #return attrs[attr_name.to_sym]
+        end
+      end
+      
+      super(attr_name)
+    end
+
+    # Overrides AR::Base#write_attribute
+    def write_attribute(attr_name, value)
+      #puts "attempting to write: #{attr_name} = #{value}"
+      if dynamic_attribute?(attr_name)
+        #puts "#{attr_name} is a dynamic_attribute"
+        attr_name = attr_name.to_s
+        
+        @save_dynamic_attr ||= {} # create the cache if needed
+        return @save_dynamic_attr[attr_name] = value
+      end
+      
+      super(attr_name, value)
+    end
+  end
+end

data/lib/datts_right/page.rb

@@ -0,0 +1,3 @@
+class Page < ActiveRecord::Base
+  has_datts
+end

data/lib/datts_right/query_methods.rb

@@ -0,0 +1,15 @@
+module DattsRight
+  module QueryMethods
+    puts "in DattsRight::QueryMethods"
+    def order(*args)
+      puts "In DattsRight::QueryMethods#order with these args: #{args}"
+      relation = clone
+      puts "= This is the relation: #{relation.inspect}"
+      relation.order_values += args.flatten unless args.blank?
+      puts "= This is the relation.order_values: #{relation.order_values.inspect}"
+      relation
+    end
+  end
+end
+
+ActiveRecord::QueryMethods.extend DattsRight::QueryMethods

data/lib/generators/migration/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate migration Thing
+
+    This will create:
+        what/will/it/create

data/lib/generators/migration/migration_generator.rb

@@ -0,0 +1,3 @@
+class MigrationGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('../templates', __FILE__)
+end

data/spec/datt_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Datt do
+  before do
+    reset_database
+    @page = Page.create
+  end
+
+  it "should allow transferring between String and Text" do
+    @page.add_dynamic_attribute(:foo, "string")
+    @page.foo = "this is a string"
+    @page.save
+    @page.foo = "t"*300
+    @page.save
+    @page.datts.find_by_attr_key("foo").object_type.should == "text"
+    @page.foo = "this is a string again"
+    @page.save
+    @page.datts.find_by_attr_key("foo").object_type.should == "string"
+  end
+end

data/spec/datts_right_spec.rb

@@ -0,0 +1,299 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe DattsRight do
+  before do
+    reset_database
+    @page = Page.create
+  end
+
+  describe ".add_dynamic_attribute(attr_key, object_type)" do
+    it "should add a dynamic attribute with nil value" do
+      @page.add_dynamic_attribute(:rocks, "string")
+      @page.dynamic_attributes[:rocks].should be_nil
+    end
+
+    it "should ignore when trying to add same attribute" do
+      @page.add_dynamic_attribute(:rocks, "string")
+      @page.add_dynamic_attribute(:rocks, "integer")
+      @page.dynamic_columns[:rocks][:object_type].should == "string"
+    end
+
+    it "should return false if the method that is being added already exists" do
+      @page.add_dynamic_attribute(:name, "text").should be_false
+    end
+
+    it "should not make any changes to the original attribute" do
+      @page.update_attribute(:name, "juno")
+      @page.add_dynamic_attribute(:name, "text").should be_false
+      @page.name.should == "juno"
+    end
+  end
+
+  describe ".remove_dynamic_attribute(attr_key)" do
+    it "should remove the attribute completely" do
+      @page.add_dynamic_attribute(:rocks, "string")
+      @page.remove_dynamic_attribute(:rocks)
+      lambda { @page.rocks }.should raise_error(NoMethodError)
+    end
+
+    it "should not explode if the attribute being removed isn't there" do
+      @page.add_dynamic_attribute(:rocks, "string")
+      @page.remove_dynamic_attribute(:rocks)
+      lambda {
+        @page.remove_dynamic_attribute(:rocks)
+      }.should_not raise_error(NoMethodError)
+    end
+  end
+
+  describe ".dynamic_columns(reload)" do
+    it "should return an array of symbols of the available dynamic columns" do
+      @page.add_dynamic_attribute(:rocks, "string")
+      @page.is_dynamic_attribute?(:rocks).should be_true
+    end
+  end
+
+  it "should not allow arbitrary creation of attributes" do
+    lambda {
+      @page.some_field = "woot"
+    }.should raise_error(NoMethodError)
+  end
+
+  it "should allow saving of integers" do
+    @page.add_dynamic_attribute(:price, "integer")
+    @page.price = 300
+    @page.save
+    @page = Page.last
+    @page.price.should == 300
+  end
+
+  it "should allow saving of floats" do
+    @page.add_dynamic_attribute(:price, "float")
+    @page.price = 300.0
+    @page.save
+    @page = Page.last
+    @page.price.should == 300.0
+  end
+
+  it "should allow saving of true" do
+    @page.add_dynamic_attribute(:real, "boolean")
+    @page.real = true
+    @page.save
+    @page = Page.last
+    @page.real.should be_true
+  end
+
+  it "should allow saving of false" do
+    @page.add_dynamic_attribute(:real, "boolean")
+    @page.real = false
+    @page.save
+    @page = Page.last
+    @page.real.should be_false
+  end
+
+  it "should allow saving of strings" do
+    @page.add_dynamic_attribute(:real, "string")
+    @page.real = "its real alright"
+    @page.save
+    @page = Page.last
+    @page.real.should == "its real alright"
+  end
+
+  it "should allow saving of text" do
+    @page.add_dynamic_attribute(:real, "text")
+    @page.real = "t"*256
+    @page.save
+    @page = Page.last
+    @page.real.should == "t"*256
+  end
+
+  it "should cache the attribute" do
+    @page.add_dynamic_attribute(:price, "integer")
+    @page.price = 200
+    @page.price.should == 200
+  end
+
+  it "should not save the attribute if save on the attributable object isn't called" do
+    @page.add_dynamic_attribute(:price, "integer")
+    @page.price = 200
+    @page = Page.last
+    @page.price.should be_nil
+  end
+
+  it "should allow overwriting of values" do
+    @page.add_dynamic_attribute(:price, "integer")
+    @page.price = 200
+    @page.save
+    @page = Page.last
+    @page.price = 300
+    @page.save
+    @page = Page.last
+    @page.price.should == 300
+  end
+
+  it "should allow nullifying of attributes, but keeping the fields there" do
+    @page.add_dynamic_attribute(:farce, "string")
+    @page.farce = "Nothing here my friend"
+    @page.save
+    @page.farce = nil
+    @page.is_dynamic_attribute?(:farce).should be_true
+  end
+
+  describe "on dynamic find_by methods" do
+    it "should work" do
+      @page.add_dynamic_attribute(:price, "integer")
+      @page.price = 400
+      @page.save
+
+      @page_2 = Page.create
+      @page_2.add_dynamic_attribute(:price, "integer")
+      @page_2.price = 500
+      @page_2.save
+
+      Page.find_by_price(400).should include(@page)
+      Page.find_by_price(400).should_not include(@page_2)
+    end
+
+    it "should allow chaining" do
+      @page.add_dynamic_attribute(:price, "integer")
+      @page.name = "fixed"
+      @page.price = 400
+      @page.save
+
+      @page_2 = Page.create
+      @page_2.add_dynamic_attribute(:price, "integer")
+      @page_2.price = 500
+      @page_2.save
+
+      @pages = Page.where(:name => "fixed").find_by_price(400)
+      @pages.should include(@page)
+      @pages.should_not include(@page_2)
+    end
+  end
+
+  it "should allow multiple attributes" do
+    @page.add_dynamic_attribute(:price, "integer")
+    @page.price = 400
+    @page.add_dynamic_attribute(:farce, "string")
+    @page.farce = "hi"
+    @page.save
+
+    @page_2 = Page.create
+    @page_2.add_dynamic_attribute(:price, "integer")
+    @page_2.price = 400
+    @page_2.add_dynamic_attribute(:farce, "string")
+    @page_2.farce = "hitt"
+    @page_2.save
+
+    @pages = Page.find_by_farce_and_price("hi", 400)
+    @pages.should include(@page)
+    @pages.should_not include(@page_2)
+  end
+
+  describe "when the value being assigned is not of the same type (with exceptions)" do
+    before do
+      @page.add_dynamic_attribute(:price, "integer")
+    end
+
+    it "should not save the value" do
+      @page.price = 200
+      @page.save
+      @page.price = "hi there"
+      @page.save
+      Page.last.price.should == 200
+    end
+  end
+
+  it "should allow mass assignment" do
+    @page.add_dynamic_attribute(:price, "integer")
+    @page.add_dynamic_attribute(:farce, "string")
+    @page.update_attributes(:price => 200, :farce => "hi")
+    @page.price.should == 200
+    @page.farce.should == "hi"
+
+    @page.update_attributes!(:price => 300, :farce => "not farce!")
+    @page.price.should == 300
+    @page.farce.should == "not farce!"
+  end
+
+  it "should allow use of update_attribute" do
+    @page.add_dynamic_attribute(:price, "integer")
+    @page.update_attribute(:price, 200)
+    @page.price.should == 200
+  end
+
+  describe "ordering" do
+    it "should default to asc" do
+      @page.add_dynamic_attribute(:price, "integer")
+      @page.price = 2
+      @page.save
+      @page_2 = Page.create
+      @page_2.add_dynamic_attribute(:price, "integer")
+      @page_2.price = 1
+      @page_2.save
+      @page_3 = Page.create
+      @page_3.add_dynamic_attribute(:price, "float")
+      @page_3.price = 3.0
+      @page_3.save
+      @page_4 = Page.create
+      @page_4.add_dynamic_attribute(:price, "float")
+      @page_4.price = 3.5
+      @page_4.save
+
+      # What if different records have price but they are of different object_type?
+      #   page_1.price is an "integer" and it's saved in "integer_value" column
+      #   page_2.price is a "float" and it's saved in "float_value"
+      #
+      #   How would you work on Page.order_datt("price")?
+      #
+      #   Answer 1: we could require passing of the object_type in the order method
+      #     This way, we know which column to look at => order_datt("price", "integer")
+      Page.order_datt("price", "integer").should == [@page_2, @page]
+      Page.order_datt("price DESC", "float").should == [@page_4, @page_3]
+    end
+  end
+
+  describe "where_datt" do
+    it "should automatically join in the datts table" do
+      @page.add_dynamic_attribute(:price, "float")
+      @page.price = 200.0
+      @page.add_dynamic_attribute(:farce, "boolean")
+      @page.farce = true
+      @page.save
+      
+      @page_2 = Page.create
+      @page_2.add_dynamic_attribute(:price, "integer")
+      @page_2.add_dynamic_attribute(:farce, "boolean")
+      @page_2.farce = true
+      @page_2.price = 1
+      @page_2.save
+
+      @result = Page.where_datt(:price => 200.0, :farce => true)
+      @result.should include(@page)
+      @result.should_not include(@page_2)
+
+      #@result = Page.where_datt("price < :price", :price => 199.0)
+      #@result.should_not include(@page)
+      #@result.should include(@page_2)
+    end
+
+    it "should allow chaining with where scopes" do
+      @page.add_dynamic_attribute(:price, "integer")
+      @page.name = "aardvark"
+      @page.price = 200
+      @page.save
+      
+      @page_2 = Page.create
+      @page_2.add_dynamic_attribute(:price, "integer")
+      @page_2.price = 200
+      @page_2.save
+
+      @results = Page.where_datt(:price => 200).where(:name => "aardvark")
+      @results.should include(@page)
+      @results.should_not include(@page_2)
+    end
+
+    it "should return an empty array if we're looking for a field that doesn't exist" do
+      Page.where_datt(:bogus_field => "none").should be_empty
+    end
+  end
+end