datamapper 0.3.2 → 0.9.3

data/lib/data_mapper/is/tree.rb

@@ -1,121 +0,0 @@
-module DataMapper
-	module Is
-		module Tree
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      # An extension to DataMapper to easily allow the creation of tree structures from your DataMapper Models.
-      # This requires a foreign key property for your model, which by default would be called :parent_id.
-      #
-			#   Example:
-			#
-      #   class Category < DataMapper::Base
-			#			property :parent_id, :integer
-			#			property :name, :string
-			#
-      #     is_a_tree :order => "name"
-      #   end
-      #
-      #   root
-      #     +- child
-      #          +- grandchild1
-      #          +- grandchild2
-      #
-      #   root        = Category.create("name" => "root")
-      #   child       = root.children.create("name" => "child")
-      #   grandchild1 = child1.children.create("name" => "grandchild1")
-      #   grandchild2 = child2.children.create("name" => "grandchild2")
-      #
-      #   root.parent   # => nil
-      #   child.parent  # => root
-      #   root.children # => [child]
-      #   root.children.first.children.first # => grandchild1
-			#   Category.first_root  # => root
-			#   Category.roots       # => [root]
-      #
-			# The following instance methods are added:
-			# * <tt>children</tt> - Returns all nodes with the current node as their parent, in the order specified by
-			#   <tt>:order</tt> (<tt>[grandchild1, grandchild2]</tt> when called on <tt>child</tt>)
-			# * <tt>parent</tt> - Returns the node referenced by the foreign key (<tt>:parent_id</tt> by
-			#   default) (<tt>root</tt> when called on <tt>child</tt>)
-      # * <tt>siblings</tt> - Returns all the children of the parent, excluding the current node
-			#   (<tt>[grandchild2]</tt> when called on <tt>grandchild1</tt>)
-      # * <tt>generation</tt> - Returns all the children of the parent, including the current node (<tt>
-			#   [grandchild1, grandchild2]</tt> when called on <tt>grandchild1</tt>)
-      # * <tt>ancestors</tt> - Returns all the ancestors of the current node (<tt>[root, child1]</tt>
-			#   when called on <tt>grandchild2</tt>)
-      # * <tt>root</tt> - Returns the root of the current node (<tt>root</tt> when called on <tt>grandchild2</tt>)
-			#
-			# Author:: Timothy Bennett (http://lanaer.com)
-			module ClassMethods
-        # Configuration options are:
-        #
-        # * <tt>foreign_key</tt> - specifies the column name to use for tracking of the tree (default: +parent_id+)
-        # * <tt>order</tt> - makes it possible to sort the children according to this SQL snippet.
-        # * <tt>counter_cache</tt> - keeps a count in a +children_count+ column if set to +true+ (default: +false+).
-        def is_a_tree(options = {})
-          configuration = { :foreign_key => "parent_id" }
-          configuration.update(options) if options.is_a?(Hash)
-
-          belongs_to :parent, :class_name => name, :foreign_key => configuration[:foreign_key], :counter_cache => configuration[:counter_cache]
-          has_many :children, :class_name => name, :foreign_key => configuration[:foreign_key], :order => configuration[:order]
-
-					include DataMapper::Is::Tree::InstanceMethods
-
-					class_eval <<-CLASS
-						def self.roots
-							self.all :#{configuration[:foreign_key]} => nil, :order => #{configuration[:order].inspect}
-						end
-
-						def self.first_root
-							self.first :#{configuration[:foreign_key]} => nil, :order => #{configuration[:order].inspect}
-						end
-					CLASS
-
-					class << self
-						alias_method :root, :first_root # for people used to the ActiveRecord acts_as_tree
-					end
-        end
-
-				alias_method :can_has_tree, :is_a_tree # just for fun ;)
-      end
-
-      module InstanceMethods
-        # Returns list of ancestors, starting with the root.
-        #
-        #   grandchild1.ancestors # => [root, child]
-        def ancestors
-          node, nodes = self, []
-          nodes << node = node.parent while node.parent
-          nodes.reverse
-        end
-
-        # Returns the root node of the current node’s tree.
-				#
-				#		grandchild1.root # => root
-        def root
-          node = self
-          node = node.parent while node.parent
-          node
-        end
-
-        # Returns all siblings of the current node.
-        #
-        #   grandchild1.siblings # => [grandchild2]
-        def siblings
-          generation - [self]
-        end
-
-        # Returns all children of the current node’s parent.
-        #
-        #   grandchild1.generation # => [grandchild1, grandchild2]
-        def generation
-          parent ? parent.children : self.class.roots
-        end
-
-				alias_method :self_and_siblings, :generation # for those used to the ActiveRecord acts_as_tree
-      end
-		end
-	end
-end

data/lib/data_mapper/migration.rb

@@ -1,155 +0,0 @@
-module DataMapper
-  class Migration
-    class Table
-      
-      MAPPINGS = DataMapper::Adapters::Sql::Mappings unless defined?(MAPPINGS)
-      
-      attr_accessor :name
-      
-      def initialize(table = nil, options = {})
-        @name, @options = table, options
-        @columns = []
-      end
-      
-      def self.create(table)
-        table.create!
-      end
-      
-      def self.drop(table_name)
-        database.table(klass(table_name)).drop!
-      end
-      
-      def self.add_column(table, column, type, options = {})
-        column = table.add_column column, type, options
-        column.create!
-      end
-      
-      def self.remove_column(table, column)
-        column = table[column]
-        column.drop!
-      end
-      
-      def add(column, type, options = {})
-        column_data = [column, type, options]
-        exists? ? self.class.add_column(table, *column_data) : table.add_column(*column_data)
-      end
-      
-      def remove(column)
-        self.class.remove_column table, column
-      end
-      
-      def rename(old_column, new_column)
-        column = table[old_column]
-        column.rename!(new_column)
-      end
-      
-      def alter(column, type, options = {})
-        column = table[column]
-        column.type = type
-        column.options = options
-        column.parse_options!
-        column.alter!
-      end
-      
-      def exists?
-        database.table_exists?(klass)
-      end
-      
-      def after_create!
-        unless exists?
-          table.add_column(:id, :integer, { :key => true }) unless @options[:id] == false
-          self.class.create(table)
-        end
-      end
-      
-      # Rails Style
-      
-      def column(name, type, options = {})
-        add(name, type, options)
-      end
-      
-      # klass!
-      
-      def table
-        @table ||= database.table(klass)
-      end
-      
-      def klass
-        @klass ||= self.class.klass(self.name)
-      end
-      
-      def self.klass(table)
-        table_name = table.to_s
-        class_name = Inflector::classify(table_name)
-        klass = Inflector::constantize(class_name)
-      rescue NameError
-        module_eval <<-classdef
-        class ::#{class_name} < DataMapper::Base
-        end
-        classdef
-        klass = eval("#{class_name}")
-      ensure
-        klass
-      end
-      
-    end
-    
-    class << self
-      
-      def up; end
-      
-      def down; end
-      
-      def migrate(direction = :up)
-        send(direction)
-      end
-      
-      def table(table = nil, options = {}, &block)
-        if table && block
-          table = DataMapper::Migration::Table.new(table, options)
-          table.instance_eval &block
-          table.after_create!
-        else
-          return DataMapper::Migration::Table
-        end
-      end
-      
-      # Rails Style
-      
-      def create_table(table_name, options = {}, &block)
-        new_table = table.new(table_name, options)
-        yield new_table
-        new_table.after_create!
-      end
-      
-      def drop_table(table_name)
-        table.drop(table_name)
-      end
-      
-      def add_column(table_name, column, type, options = {})
-        table table_name do
-          add column, type, options
-        end
-      end
-      
-      def rename_column(table_name, old_column_name, new_column_name)
-        table table_name do
-          rename old_column_name, new_column_name
-        end
-      end
-      
-      def change_column(table_name, column_name, type, options = {})
-        table table_name do
-          alter column_name, type, options
-        end
-      end
-      
-      def remove_column(table_name, column)
-        table table_name do
-          remove column
-        end
-      end
-    end
-  end
-  
-end

data/lib/data_mapper/persistence.rb

@@ -1,852 +0,0 @@
-require 'data_mapper/property'
-require 'data_mapper/attributes'
-require 'data_mapper/support/serialization'
-require 'data_mapper/validations'
-require 'data_mapper/associations'
-require 'data_mapper/callbacks'
-require 'data_mapper/embedded_value'
-require 'data_mapper/auto_migrations'
-require 'data_mapper/dependency_queue'
-require 'data_mapper/support/struct'
-
-module DataMapper
-  # See DataMapper::Persistence::ClassMethods for DataMapper's DSL documentation.
-  module Persistence
-
-    class IncompleteModelDefinitionError < StandardError
-    end
-
-    # This probably needs to be protected
-    attr_accessor :loaded_set
-
-    include Comparable
-
-    def self.included(klass)
-
-      klass.extend(ClassMethods)
-      klass.extend(ConvenienceMethods::ClassMethods)
-
-      klass.send(:include, ConvenienceMethods::InstanceMethods)
-      klass.send(:include, Attributes)
-      klass.send(:include, Associations)
-      klass.send(:include, Validations)
-      klass.send(:include, CallbacksHelper)
-      klass.send(:include, Support::Serialization)
-
-      klass.instance_variable_set('@properties', [])
-
-      klass.send :extend, AutoMigrations
-      klass.subclasses
-      DataMapper::Persistence::subclasses << klass unless klass == DataMapper::Base
-      klass.send(:undef_method, :id) if method_defined?(:id)
-
-      # When this class is sub-classed, copy the declared columns.
-      klass.class_eval do
-        def self.subclasses
-          @subclasses || (@subclasses = Support::TypedSet.new(Class))
-        end
-
-        def self.inherited(subclass)
-          super_table = database.table(self)
-
-          if super_table.type_column.nil?
-            super_table.add_column(:type, :class, {})
-          end
-
-          subclass.instance_variable_set('@properties', self.instance_variable_get("@properties").dup)
-          subclass.instance_variable_set("@callbacks", self.callbacks.dup)
-
-          self::subclasses << subclass
-        end
-
-        def self.persistent?
-          true
-        end
-      end
-    end
-
-    #  Migrates the database schema based on the properties defined within
-    #  models. This includes removing fields no longer listed in models and
-    #  adding new ones.
-    #
-    # This is destructive. Any data stored in the database will be destroyed
-    # when this method is called.
-    #
-    # ==== Returns
-    #  True:: successfully automigrated database
-    #  False:: an error occured when automigrating the database
-    #
-    # @public
-    def self.auto_migrate!
-      subclasses.each do |subclass|
-        subclass.auto_migrate!
-      end
-    end
-
-
-    # Drops all tables known by the schema
-    #
-    # ==== Returns
-    #  True:: successfully automigrated database
-    #  False:: an error occured when automigrating the database
-    #
-    # @public
-    def self.drop_all_tables!
-      database.adapter.schema.each do |table|
-        table.drop!
-      end
-    end
-
-    # Track classes that include this module.
-    # ==== Returns
-    #  Support::TypedSet::
-    #    contains classes that include or inherit from this module
-    #
-    # @semipublic
-    def self.subclasses
-      @subclasses || (@subclasses = Support::TypedSet.new(Class))
-    end
-
-    # Track classes that include this module.
-    # ==== Returns
-    #  Support::TypedSet::
-    #    contains classes that include or inherit from this module
-    #
-    # @semipublic
-    def self.dependencies
-      @dependency_queue || (@dependency_queue = DependencyQueue.new)
-    end
-    
-    def initialize(details = nil)
-      check_for_properties!
-      if details
-        initialize_with_attributes(details)
-      end
-    end
-    
-    def initialize_with_attributes(details)
-      case details
-      when Hash then self.attributes = details
-      when details.respond_to?(:persistent?) then self.private_attributes = details.attributes
-      when Struct then self.private_attributes = details.attributes
-      end
-    end    
-
-    def check_for_properties!
-      raise IncompleteModelDefinitionError.new("Models must have at least one property to be initialized.") if self.class.properties.empty?
-    end
-
-    module ConvenienceMethods
-      module InstanceMethods
-        
-        # Save updated properties to the database.
-        #
-        # ==== Returns
-        #  True::  successfully saved the object to the database
-        #  False:: an error occured when saving the object to the database.
-        #          check valid? to see if validation error occured
-        #
-        # @public
-        def save
-          database_context.save(self)
-        end
-
-        # This behaves in the same way as save, but raises a ValidationError
-        # if the model is invalid. Successful saves return true. 
-        # 
-        # ==== Returns
-        #  True:: successfully saved the object to the database
-        #
-        # ==== Raises
-        #  ValidationError::
-        #     The object could not be saved to the database due to validation
-        #     errors
-        # @public
-        def save!
-          raise ValidationError.new(errors) unless save
-          return true
-        end
-
-        # Reloads a model's properties from the database. This also includes
-        # data for any associated models that have been loaded from the
-        # database.
-        #
-        # You can limit the properties being reloaded by passing in an array
-        # of symbols.
-        def reload!(cols = nil)
-          database_context.first(self.class, key, :select => ([self.class.table.key.to_sym] + (cols || original_values.keys)).uniq, :reload => true)
-          self.loaded_associations.each { |association| association.reload! }
-          self
-        end
-        alias reload reload!
-        
-        # Deletes the model from the database and de-activates associations
-        def destroy!
-          database_context.destroy(self)
-        end
-      end
-
-      module ClassMethods
-        
-        # Attempts to find an object using options passed as
-        # search_attributes, and falls back to creating the object if it
-        # can't find it.
-        #
-        # ==== Parameters
-        # search_attributes <hash>::
-        #   attributes used to perform the search, and which can be later
-        #   merged with create_attributes when creating a record
-        # create_attributes <hash>::
-        #   attributes which are merged into the search_attributes when a
-        #   record is unfound and needs to be created
-        #
-        # ==== Returns
-        # Object:: the found or created object from the database
-        #
-        # ==== Raises
-        # ValidationError::
-        #   An object was not found, and could not be created due to errors 
-        #   in validation.
-        #  DataObject::QueryError::
-        #    The database threw an error
-        # -
-        # @public
-        def find_or_create(search_attributes, create_attributes = {})
-          first(search_attributes) || create(search_attributes.merge(create_attributes))
-        end
-
-        # returns an array of objects matching <tt>options</tt>.
-        #
-        # ==== Parameters
-        #  options <hash>::
-        #    hash of parameters to search by
-        #
-        # ==== Returns
-        #  Array:: contains all matched objects from the database, or an 
-        #          empty set
-        #
-        # ==== Options
-        # Basics:
-        #   Widget.all                                          # => no conditions
-        #   Widget.all :order => 'created_at desc'              # => ORDER BY created_at desc
-        #   Widget.all :limit => 10                             # => LIMIT 10
-        #   Widget.all :offset => 100                           # => OFFSET 100
-        #   Widget.all :include => [:gadgets]                   # => performs the JOIN according to
-        #                                                            its association with Gadgets
-        #
-        # Any non-standard options are assumed to be column names and are ANDed together: 
-        #   Widget.all :age => 10                               # => WHERE age = 10
-        #   Widget.all :age => 10, :title => 'Toy'              # => WHERE age = 10 AND title = 'Toy'
-        #
-        # Using Symbol Operators[link:classes/DataMapper/Support/Symbol/Operator.html]:
-        #   Widget.all :age.gt => 20                            # => WHERE age > 10
-        #   Widget.all :age.gte => 20, :name.like => '%Toy%'    # => WHERE age >= 10 and name like '%Toy%'
-        # 
-        # Variations of syntax include the :conditions => {} as well as interpolated arrays
-        #   Widget.all :conditions => {:age => 10}              # => WHERE age = 10
-        #   Widget.all :conditions => ["age = ?", 10]           # => WHERE age = 10
-        #
-        # Syntaxes can be mixed-and-matched as well
-        #   Widget.all :conditions => ["age = ?", 10], :title => 'Toy'
-        #   # => WHERE age = 10 AND title = 'Toy'
-        #
-        # ==== Raises
-        # DataMapper::Adapters::Sql::Commands::LoadCommand::ConditionsError::
-        #  A query could not be constructed from the hash passed in as
-        #  <tt>options</tt>
-        #  DataObject::QueryError::
-        #    The database threw an error
-        # - 
-        # @public
-        def all(options = {})
-          database.all(self, options)
-        end
-
-        # Allows you to iterate over a collection of matching records. The
-        # first argument is the find options. The second is a block that will
-        # be called for every matching record.
-        #
-        # The valid options are the same as those documented in #all, 
-        # except the <tt>:offset</tt> option, which is not allowed.
-        def each(options = {}, &b)
-          raise ArgumentError.new(":offset is not supported with the #each method") if options.has_key?(:offset)
-
-          offset = 0
-          limit = options[:limit] || (self::const_defined?('DEFAULT_LIMIT') ? self::DEFAULT_LIMIT : 500)
-
-          until (results = all(options.merge(:limit => limit, :offset => offset))).empty?
-            results.each(&b)
-            offset += limit
-          end
-        end
-
-        # Returns the first object which matches the query generated from the arguments
-        #
-        # ==== Parameters
-        #  see all()
-        #
-        # ==== Returns
-        #  Object:: first object from the database which matches the query
-        #  nil::  no object could be found which matches the query
-        #
-        # ==== Raises
-        #  DataMapper::Adapters::Sql::Commands::LoadCommand::ConditionsError::
-        #    A query could not be generated from the arguments passed in
-        #  DataObject::QueryError::
-        #    The database threw an error
-        # - 
-        # @public
-        def first(*args)
-          database.first(self, *args)
-        end
-
-        # returns the count of rows that match the given options hash.  See
-        # all() for a list of possible arguments.
-        # NOTE: discards <tt>:offset</tt>, <tt>:limit</tt>, <tt>:order</tt>
-        #
-        # ==== Parameters
-        #  see all().
-        #
-        # ==== Returns
-        #  Integer:: number of rows matching query
-        #
-        # ==== Raises
-        #  DataMapper::Adapters::Sql::Commands::LoadCommand::ConditionsError::
-        #    A query could not be generated from the arguments passed in
-        #  DataObject::QueryError::
-        #    The database threw an error
-        # - 
-        # @public
-        def count(*args)
-          database.count(self, *args)
-        end
-
-        # Does what it says. Deletes all records in a model's table. 
-        # before_destroy and after_destroy callbacks are called and
-        # paranoia is respected.
-        #
-        # ==== Returns
-        #  nil:: successfully deleted all rows
-        #
-        # ==== Raises
-        #  DataObject::QueryError::
-        #    The database threw an error
-        # - 
-        # @public
-        def delete_all
-          database.delete_all(self)
-        end
-
-        def truncate!
-          database.truncate(self)
-        end
-        
-        # This method allows for ActiveRecord style queries. The first
-        # argument is a symbol indicating a search for a single record or a
-        # collection — <tt>:first</tt> and <tt>:all</tt> respectively. The
-        # second argument is the hash of options for your query. For a list 
-        # of valid options, please refer to the #all method.
-        #
-        #   Widget.find(:all,   :active => true)    # => An array of active widgets
-        #   Widget.find(:first, :active => true)    # => The first active widget found
-        def find(type_or_id, options = {})
-          case type_or_id
-            when :first then first(options)
-            when :all then all(options)
-            else first(type_or_id, options)
-          end
-        end
-        
-        # supply this method with the full SQL you wish to search on, and it
-        # will return an array of Structs with your results set in them.
-        #
-        # NOTE: this does NOT return objects of a specific type, but rather
-        # Struct objects with as many attributes as what you requested in 
-        # your full SQL query. These structs are read-only.
-        #
-        # If you only indicate you want 1 specific column, Datamapper and
-        # DataObjects will do their best to type-cast the result as best they
-        # can, rather than supplying you with an array of length 1 containing
-        # Structs with 1 attribute.
-        def find_by_sql(*args)
-          DataMapper::database.query(*args)
-        end
-
-        # finds a single row from the database by it's primary key. 
-        # If you declared a property with <tt>:key => true</tt>, it's safe to 
-        # use here.
-        # Example:
-        #   Widget.get(100)                                        # => widget with the primary key of 100
-        #   Widget.get('Toy')                                      # => widget with the primary natural key of 'Toy'
-        def get(*keys)
-          database.get(self, keys)
-        end
-
-
-        # synonym for get()
-        # ==== Parameters
-        #  keys <any>:: keys which which to look up objects in the table.  
-        #
-        # ==== Returns
-        #  object :: object matching the request
-        #
-        # ==== Raises
-        #  DataMapper::ObjectNotFoundError
-        #    could not find the object requested
-        # - 
-        # @public
-        def [](*keys)
-          # Eventually this ArgumentError should be removed. It's only here 
-          # to help
-          # migrate users away from the [options_hash] syntax, which is no
-          # longer supported.
-          raise ArgumentError.new('Hash is not a valid key') if keys.size == 1 && keys.first.is_a?(Hash)
-          instance = database.get(self, keys)
-          raise ObjectNotFoundError.new() unless instance
-          return instance
-        end
-
-        # creates (and saves) a new instance of the object.
-        def create(attributes)
-          instance = self.new_with_attributes(attributes)
-          instance.save
-          instance
-        end
-
-        # the same as create(), though will raise an ObjectNotFoundError if
-        # the instance could not be saved
-        def create!(attributes)
-          instance = create(attributes)
-          raise ObjectNotFoundError.new(instance) if instance.new_record?
-          instance
-        end
-      end
-    end
-
-    module ClassMethods
-
-      def new_with_attributes(details)
-        instance = allocate
-        instance.initialize_with_attributes(details)
-        instance
-      end
-      
-      # Track classes that include this module.
-      def subclasses
-        @subclasses || (@subclasses = [])
-      end
-
-      def logger
-        database.logger
-      end
-
-      def transaction
-        yield
-      end
-
-      # The foreign key for a model. It is based on the lowercased and
-      # underscored name of the class, suffixed with <tt>_id</tt>.
-      #
-      #   Widget.foreign_key    # => "widget_id"
-      #   NewsItem.foreign_key  # => "news_item_id"
-      def foreign_key
-        Inflector.underscore(self.name) + "_id"
-      end
-
-      def extended(klass)
-      end
-
-      def table
-        database.table(self)
-      end
-
-      # Adds property accessors for a field that you'd like to be able to
-      # modify.  The DataMapper doesn't
-      # use the table schema to infer accessors, you must explicity call
-      # #property to add field accessors
-      # to your model. 
-      #
-      # Can accept an unlimited amount of property names. Optionally, you may
-      # pass the property names as an 
-      # array.
-      #
-      # For more documentation, see Property.
-      #
-      # EXAMPLE:
-      #   class CellProvider
-      #     property :name, :string
-      #     property :rating_number, :rating_percent, :integer # will create two properties with same type and text
-      #     property [:bill_to, :ship_to, :mail_to], :text, :lazy => false # will create three properties all with same type and text
-      #   end
-      #
-      #   att = CellProvider.new(:name => 'AT&T')
-      #   att.rating = 3
-      #   puts att.name, att.rating
-      #
-      #   => AT&T
-      #   => 3
-      #
-      # OPTIONS:
-      #   * <tt>lazy</tt>: Lazy load the specified property (:lazy => true). False by default.
-      #   * <tt>accessor</tt>: Set method visibility for the property accessors. Affects both
-      #   reader and writer. Allowable values are :public, :protected, :private. Defaults to
-      #   :public
-      #   * <tt>reader</tt>: Like the accessor option but affects only the property reader.
-      #   * <tt>writer</tt>: Like the accessor option but affects only the property writer.
-      #   * <tt>protected</tt>: Alias for :reader => :public, :writer => :protected
-      #   * <tt>private</tt>: Alias for :reader => :public, :writer => :private
-      
-      def property(*columns_and_options)        
-        columns, options = columns_and_options.partition {|item| not item.is_a?(Hash)}
-        options = (options.empty? ? {} : options[0])
-        type = columns.pop
-      
-        @properties ||= []
-        new_properties = []
-      
-        columns.flatten.each do |name|
-          property = DataMapper::Property.new(self, name, type, options)
-          new_properties << property
-          @properties << property
-        end
-              
-        return (new_properties.length == 1 ? new_properties[0] : new_properties)
-      end
-      
-      # TODO: Figure out how to make EmbeddedValue work with new property
-      # code. EV relies on these next two methods.
-      def property_getter(mapping, visibility = :public)
-        if mapping.lazy?
-          class_eval <<-EOS
-          #{visibility.to_s}
-          def #{mapping.name}
-            lazy_load!(#{mapping.name.inspect})
-            class << self;
-              attr_accessor #{mapping.name.inspect}
-            end
-            @#{mapping.name}
-          end
-          EOS
-        else
-          class_eval("#{visibility.to_s}; def #{mapping.name}; #{mapping.instance_variable_name} end") unless [ :public, :private, :protected ].include?(mapping.name)
-        end
-
-        if mapping.type == :boolean
-          class_eval("#{visibility.to_s}; def #{mapping.name.to_s.ensure_ends_with('?')}; #{mapping.instance_variable_name} end")
-        end
-
-      rescue SyntaxError
-        raise SyntaxError.new(mapping)
-      end
-
-      def property_setter(mapping, visibility = :public)
-        if mapping.lazy?
-          class_eval <<-EOS
-          #{visibility.to_s}
-          def #{mapping.name}=(value)
-            class << self;
-              attr_accessor #{mapping.name.inspect}
-            end
-            @#{mapping.name} = value
-          end
-          EOS
-        else
-          class_eval("#{visibility.to_s}; def #{mapping.name}=(value); #{mapping.instance_variable_name} = value end")
-        end
-      rescue SyntaxError
-        raise SyntaxError.new(mapping)
-      end
-
-      # Allows you to override the table name for a model.
-      # EXAMPLE:
-      #   class WorkItem
-      #     set_table_name 't_work_item_list'
-      #   end
-      def set_table_name(value)
-        database.table(self).name = value
-      end
-      
-      # An embedded value maps the values of an object to fields in the 
-      # record of the object's owner.
-      # #embed takes a symbol to define the embedded class, options, and 
-      # an optional block. See
-      # examples for use cases.
-      #
-      # EXAMPLE:
-      #   class CellPhone < DataMapper::Base
-      #     property :number, :string
-      #
-      #     embed :owner, :prefix => true do
-      #       property :name, :string
-      #       property :address, :string
-      #     end
-      #   end
-      #
-      #   my_phone = CellPhone.new
-      #   my_phone.owner.name = "Nick"
-      #   puts my_phone.owner.name
-      #
-      #   => Nick
-      #
-      # OPTIONS:
-      # * <tt>prefix</tt>:   define a column prefix, so instead of mapping
-      #                      :address to an 'address' column, it would map to
-      #                      'owner_address' in the example above. If 
-      #                      :prefix => true is specified, the prefix will
-      #                      be the name of the symbol given as the first 
-      #                      parameter. If the prefix is a string the 
-      #                      specified 
-      #                      string will be used for the prefix.
-      # * <tt>lazy</tt>:     lazy-load all embedded values at the same time. 
-      #                      :lazy => true to enable. Disabled (false) by
-      #                      default.
-      # * <tt>accessor</tt>: Set method visibility for all embedded
-      #                      properties. Affects both reader and writer.
-      #                      Allowable values are :public, :protected,
-      #                      :private. Defaults to :public
-      # * <tt>reader</tt>:   Like the accessor option but affects only
-      #                      embedded property readers.
-      # * <tt>writer</tt>:   Like the accessor option but affects only 
-      #                      embedded property writers.
-      # * <tt>protected</tt>: Alias for :reader => :public, 
-      #                       :writer => :protected
-      # * <tt>private</tt>: Alias for :reader => :public, :writer => :private
-      #
-      def embed(name, options = {}, &block)
-        EmbeddedValue::define(self, name, options, &block)
-      end
-      
-      # Returns the hash of properties for this model.
-      def properties
-        @properties
-      end
-
-      # Creates a composite index for an arbitrary number of database columns.
-      # Note that it also is possible to specify single indexes directly for
-      # each property.
-      #
-      # === EXAMPLE WITH COMPOSITE INDEX:
-      #   class Person < DataMapper::Base
-      #     property :server_id, :integer
-      #     property :name, :string
-      #
-      #     index [:server_id, :name]
-      #   end
-      #
-      # === EXAMPLE WITH COMPOSITE UNIQUE INDEX:
-      #   class Person < DataMapper::Base
-      #     property :server_id, :integer
-      #     property :name, :string
-      #
-      #     index [:server_id, :name], :unique => true
-      #   end
-      #
-      # === SINGLE INDEX EXAMPLES:
-      # * property :name, :index => true
-      # * property :name, :index => :unique
-      def index(indexes, unique = false)
-        if indexes.kind_of?(Array) # if given an index of multiple columns
-          database.schema[self].add_composite_index(indexes, unique)
-        else
-          raise ArgumentError.new("You must supply an array for the composite index")
-        end
-      end
-
-    end
-
-    # Lazy-loads the attributes for a loaded_set, then overwrites the
-    # accessors
-    # for the named methods so that the lazy_loading is skipped the second
-    # time.
-    def lazy_load!(*names)
-
-      names = names.map { |name| name.to_sym }.reject { |name| lazy_loaded_attributes.include?(name) }
-
-      reset_attribute = lambda do |instance|
-        singleton_class = (class << instance; self end)
-        names.each do |name|
-          instance.lazy_loaded_attributes << name
-          singleton_class.send(:attr_accessor, name)
-        end
-      end
-
-      unless names.empty? || new_record? || loaded_set.nil?
-
-        key = database_context.table(self.class).key.to_sym
-        keys_to_select = loaded_set.map do |instance|
-          instance.send(key)
-        end
-
-        database_context.all(
-          self.class,
-          :select => ([key] + names),
-          :reload => true,
-          key => keys_to_select
-        ).each(&reset_attribute)
-      else
-        reset_attribute[self]
-      end
-    end
-
-    def database_context
-      @database_context || ( @database_context = database )
-    end
-
-    def database_context=(value)
-      @database_context = value
-    end
-
-    def logger
-      self.class.logger
-    end
-
-    # Returns <tt>true</tt> if this model hasn't been saved to the 
-    # database, <tt>false</tt> otherwise.
-    def new_record?
-      @new_record.nil? || @new_record
-    end
-
-    # Returns a Set containing the properties that have had their
-    # <tt>:lazy</tt> option set to true, or are lazily loaded by 
-    # default — i.e. text fields.
-    def lazy_loaded_attributes
-      @lazy_loaded_attributes || @lazy_loaded_attributes = Set.new
-    end
-
-    # Accepts a hash of properties and values to be updated and then calls #save
-    def update_attributes(update_hash)
-      self.attributes = update_hash
-      self.save
-    end
-
-    # Returns <tt>true</tt> if the unsaved model has had properties changed
-    # since it was loaded from the database. Returns <tt>false</tt> otherwise.
-    def dirty?(cleared = Set.new)
-      return false if cleared.include?(self)
-      cleared << self
-
-      result = database_context.table(self).columns.any? do |column|
-        if column.type == :object
-          Marshal.dump(self.instance_variable_get(column.instance_variable_name)) != original_values[column.name]
-        else
-          self.instance_variable_get(column.instance_variable_name) != original_values[column.name]
-        end
-      end
-
-      return true if result
-
-      loaded_associations.any? do |loaded_association|
-        loaded_association.dirty?(cleared)
-      end
-    end
-
-    # For unsaved models, returns a hash of properties that have had their
-    # values changed since it was loaded from the database.
-    def dirty_attributes
-      pairs = {}
-
-      database_context.table(self).columns.each do |column|
-        value = instance_variable_get(column.instance_variable_name)
-        if value != original_values[column.name] && (!new_record? || !column.serial?)
-          pairs[column.name] = column.type != :object ? value : YAML.dump(value)
-        end
-      end
-
-      pairs
-    end
-
-    def original_values=(values)
-      values.each_pair do |k,v|
-        original_values[k] = case v
-        	when String, Date, Time then v.dup
-                  # when column.type == :object then Marshal.dump(v)
-        	else v
-        end
-      end
-    end
-
-    def original_values
-      class << self
-        attr_reader :original_values
-      end
-
-      @original_values = {}
-    end
-
-    def loaded_set=(value)
-      value << self
-      @loaded_set = value
-    end
-
-    def inspect
-      inspected_attributes = attributes.map { |k,v| "@#{k}=#{v.inspect}" }
-
-      instance_variables.each do |name|
-        if instance_variable_get(name).kind_of?(Associations::HasManyAssociation)
-          inspected_attributes << "#{name}=#{instance_variable_get(name).inspect}"
-        end
-      end
-
-      "#<%s:0x%x @new_record=%s, %s>" % [self.class.name, (object_id * 2), new_record?, inspected_attributes.join(', ')]
-    end
-
-    def loaded_associations
-      @loaded_associations || @loaded_associations = []
-    end
-
-    def key=(value)
-      key_column = database_context.table(self.class).key
-      @__key = key_column.type_cast_value(value)
-      instance_variable_set(key_column.instance_variable_name, @__key)
-    end
-
-    def key
-      @__key || @__key = begin
-        key_column = database_context.table(self.class).key
-        key_column.type_cast_value(instance_variable_get(key_column.instance_variable_name))
-      end
-    end
-
-    def keys
-      self.class.table.keys.map do |column|
-        column.type_cast_value(instance_variable_get(column.instance_variable_name))
-      end.compact
-    end
-
-    def <=>(other)
-      keys <=> other.keys
-    end
-
-    # Look to ::included for __hash alias
-    def hash
-      @__hash || @__hash = keys.empty? ? super : keys.hash
-    end
-
-    def eql?(other)
-      return false unless other.is_a?(self.class) || self.is_a?(other.class)
-      comparator = keys.empty? ? :private_attributes : :keys
-      send(comparator) == other.send(comparator)
-    end
-
-    def ==(other)
-      eql?(other)
-    end
-
-    # Returns the difference between two objects, in terms of their
-    # attributes.
-    def ^(other)
-      results = {}
-
-      self_attributes, other_attributes = attributes, other.attributes
-
-      self_attributes.each_pair do |k,v|
-        other_value = other_attributes[k]
-        unless v == other_value
-          results[k] = [v, other_value]
-        end
-      end
-
-      results
-    end
-  end
-end