datamapper 0.2.5 → 0.3.0

data/lib/data_mapper/auto_migrations.rb

@@ -3,9 +3,7 @@ module DataMapper
     def auto_migrate!
       if self::subclasses.empty?
         table = database.table(self)
-        table.associations.each do |association|
-          association.activate!
-        end
+        table.activate_associations!
         
         table.create!(true)
       else
@@ -20,9 +18,7 @@ module DataMapper
           table.add_column(column.name, column.type, column.options)
         end
         
-        table.associations.each do |association|
-          association.activate!
-        end
+        table.activate_associations!
         
         return table.create!(true)
       end

data/lib/data_mapper/base.rb

@@ -1,21 +1,17 @@
 require 'data_mapper/persistence'
-
-begin
-  require 'ferret'
-rescue LoadError
-end
+require 'data_mapper/is/tree'
 
 module DataMapper
 
   class Base
-    include DataMapper::Persistence
+		include DataMapper::Is::Tree
     
     def self.inherited(klass)
-      DataMapper::Persistence::prepare_for_persistence(klass)
+      klass.send(:include, DataMapper::Persistence)
     end
 
-    def self.subclasses
-      []
+    def self.auto_migrate!
+      DataMapper::Persistence.auto_migrate!
     end
   end
 end

data/lib/data_mapper/database.rb

@@ -102,7 +102,7 @@ module DataMapper
     #
     # This is what gives us thread safety, boys and girls
     def self.context
-      Thread::current[:context] || Thread::current[:context] = []
+      Thread::current[:database_contexts] || Thread::current[:database_contexts] = []
     end
     
     # Setup creates a database and sets all of your properties for that database.
@@ -158,13 +158,14 @@ module DataMapper
     # Creates a new database object with the name you specify, and a default set of options.
     #
     # The default options are as follows:
-    #   { :host => 'localhost', :database => nil, :username => 'root', :password => '', :adapter = nil }
+    #   { :host => 'localhost', :database => nil, :port => nil, :username => 'root', :password => '', :adapter = nil }
     def initialize(name)
       @name = name
       
       @adapter = nil
       @host = 'localhost'
       @database = nil
+      @port = nil
       @schema_search_path = nil
       @username = 'root'
       @password = ''
@@ -176,7 +177,7 @@ module DataMapper
     
     attr_reader :name, :adapter, :log_stream
     
-    attr_accessor :host, :database, :schema_search_path, :username, :password, :log_level, :index_path, :socket
+    attr_accessor :host, :database, :port, :schema_search_path, :username, :password, :log_level, :index_path, :socket
     
     def log_stream=(val)
       @log_stream = (val.is_a?(String) && val =~ /STDOUT/ ? STDOUT : val)

data/lib/data_mapper/embedded_value.rb

@@ -1,73 +1,109 @@
 module DataMapper
   
+# == EmbeddedValue
+# As an alternative to an extraneous has_one association, EmbeddedValue offers a means 
+# to serialize component objects to a table without having to define an entirely new model.
+#
+# Example:
+#
+#   class Person < DataMapper::Base 
+#     
+#     property :name, :string
+#     property :occupation, :string
+#     
+#     embed :address, :prefix => true do
+#       property :street, :string
+#       property :city, :string
+#       property :state, :string, :size => 2
+#       property :zip_code, :string, :size => 10
+#       
+#       def city_state_zip_code
+#         "#{city}, #{state} #{zip_code}"
+#       end
+#       
+#     end 
+#   end
+#
+# Columns for the Address model will appear in the Person table.  Passing 
+# <tt>:prefix => true</tt> will prefix the column name with the parent table's name.
+# The default behavior is to use the columns as they are defined.  Using the above
+# example, the database table structure will become:
+#
+#   Column                      Datatype, Options
+#   ===============================================================
+#   name                         :string
+#   occupation                   :string
+#   address_street               :string
+#   address_city                 :string
+#   address_state                :string, :size => 2
+#   address_zip_code             :string, :size => 10
+#
+# EmbeddedValue's become instance methods off of an instance of the parent 
+# class and return a sub-class of the parent class.
+#
+#   bob = Person.first(:name => 'Bob')
+#   bob.address                         # => #<Person::Address:0x1a492b8>
+#   bob.address.city                    # => "Pittsburgh"
+#   bob.address.city_state_zip_code     # => "Pitsburgh, PA 90210"
+  
   class EmbeddedValue
     EMBEDDED_PROPERTIES = []
     
     def initialize(instance)
       @instance = instance
       @container_prefix = ''
-
-      # force lazy load on access to any lazy-loaded embed property
-      @instance.lazy_load!(*self.class::EMBEDDED_PROPERTIES) # if @container_lazy
     end
 
     def self.inherited(base)
       base.const_set('EMBEDDED_PROPERTIES', [])
     end
     
-    # add an embedded property
+    # add an embedded property.  For more information about how to define properties, visit Property.
     def self.property(name, type, options = {})
       # set lazy option on the mapping if defined in the embed block
       options[:lazy] ||= @container_lazy
-
-      visibility_options = [:public, :protected, :private]
-      reader_visibility = options[:reader] || options[:accessor] || @container_reader_visibility
-      writer_visibility = options[:writer] || options[:accessor] || @container_writer_visibility
-      writer_visibility = :protected if options[:protected]
-      writer_visibility = :private if options[:private]
-
-      raise(ArgumentError.new, "property visibility must be :public, :protected, or :private") unless visibility_options.include?(reader_visibility) && visibility_options.include?(writer_visibility)
-
-      mapping = database.schema[containing_class].add_column("#{@container_prefix}#{name}", type, options)
-
-      self::EMBEDDED_PROPERTIES << "#{@container_prefix}#{name}"
-      define_property_getter(name, mapping, reader_visibility)
-      define_property_setter(name, mapping, writer_visibility)
+      
+      options[:reader] ||= options[:accessor] || @container_reader_visibility
+      options[:writer] ||= options[:accessor] || @container_writer_visibility
+      
+      property_name = @container_prefix ? @container_prefix + name.to_s : name
+      
+      property = containing_class.property(property_name, type, options)
+      define_property_getter(name, property)
+      define_property_setter(name, property)
     end
     
     # define embedded property getters
-    def self.define_property_getter(name, mapping, visibility = :public)
-      # add convenience method on non-embedded base for #update_attributes
-      self.containing_class.property_getter(mapping, visibility)
+    def self.define_property_getter(name, property) # :nodoc:
 
       # add the method on the embedded class
       class_eval <<-EOS
-        #{visibility.to_s}
+        #{property.reader_visibility.to_s}
         def #{name}
-          @instance.instance_variable_get(#{mapping.instance_variable_name.inspect})
+          #{"@instance.lazy_load!("+ property.name.inspect + ")" if property.lazy?}
+          @instance.instance_variable_get(#{property.instance_variable_name.inspect})
         end
       EOS
 
       # add a shortcut boolean? method if applicable (ex: activated?)
-      if mapping.type == :boolean
-        class_eval("alias #{name}? #{name}")
+      if property.type == :boolean
+        class_eval("alias #{property.name}? #{property.name}")
       end
     end
     
     # define embedded property setters
-    def self.define_property_setter(name, mapping, visibility = :public)
-      # add convenience method on non-embedded base for #update_attributes
-      self.containing_class.property_setter(mapping, visibility)
+    def self.define_property_setter(name, property)  # :nodoc:
 
       # add the method on the embedded class
       class_eval <<-EOS
-        #{visibility.to_s}
+        #{property.writer_visibility.to_s}
         def #{name.to_s.sub(/\?$/, '')}=(value)
-          @instance.instance_variable_set(#{mapping.instance_variable_name.inspect}, value)
+          @instance.instance_variable_set(#{property.instance_variable_name.inspect}, value)
         end
       EOS
     end
     
+    # returns the class in which the EmbeddedValue is declared
     def self.containing_class
       @containing_class || @containing_class = begin
         tree = name.split('::')

data/lib/data_mapper/identity_map.rb

@@ -1,5 +1,3 @@
-require 'data_mapper/support/weak_hash'
-
 module DataMapper
   
   # Tracks objects to help ensure that each object gets loaded only once.
@@ -39,7 +37,7 @@ module DataMapper
     
     private
     def mapped_class(klass)
-      if ! klass.superclass.respond_to?(:persistent?)
+      unless klass.superclass.respond_to?(:persistent?)
         klass
       else
         mapped_class(klass.superclass)

data/lib/data_mapper/is/tree.rb

@@ -0,0 +1,121 @@
+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

@@ -0,0 +1,155 @@
+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