datamapper 0.3.2 → 0.9.3

data/lib/data_mapper/database.rb

@@ -1,234 +0,0 @@
-require 'logger'
-require 'data_mapper/context'
-require 'data_mapper/adapters/abstract_adapter'
-
-# Delegates to DataMapper::database.
-# Will not overwrite if a method of the same name is pre-defined.
-def database(name = :default, &block)
-  DataMapper::database(name, &block)
-end unless methods.include?(:database)
-
-module DataMapper
-  
-  # ===Block Syntax:
-  # Pushes the named database onto the context-stack, 
-  # yields a new session, and pops the context-stack.
-  #
-  #   results = DataMapper.database(:second_database) do |current_context|
-  #     ...
-  #   end
-  #
-  # ===Non-Block Syntax:
-  # Returns the current session, or if there is none,
-  # a new Session.
-  #
-  #   current_database = DataMapper.database
-  def self.database(name = :default) # :yields: current_context
-    unless block_given?
-      Database.context.last || Context.new(Database[name].adapter)
-    else
-      begin
-        Database.context.push(Context.new(Database[name].adapter))
-        return yield(Database.context.last)
-      ensure
-        Database.context.pop
-      end
-    end
-  end
-  
-  class DatabaseError < StandardError
-    attr_accessor :options
-  end
-  
-  # The Database class allows us to setup a default database for use throughout our applications
-  # or allows us to setup a collection of databases to use.
-  #
-  # === Example
-  # ==== To setup a default database
-  #   DataMapper::Database.setup({
-  #    :adapter  => 'mysql'
-  #    :host     => 'localhost'
-  #    :username => 'root'
-  #    :password => 'R00tPaswooooord'
-  #    :database => 'selecta_development'
-  #   })
-  #
-  # ==== To setup a named database
-  #   DataMapper::Database.setup(:second_database, {
-  #    :adapter  => 'postgresql'
-  #    :host     => 'localhost'
-  #    :username => 'second_user'
-  #    :password => 'second_password'
-  #    :database => 'second_database'
-  #   })
-  #
-  #
-  # ==== Working with multiple databases (see #DataMapper::database)
-  #   DataMapper.database(:second_database) do
-  #     ...
-  #   end
-  #
-  #   DataMapper.database(:default) do
-  #     ...
-  #   end
-  #
-  # or even...
-  #
-  #   #The below variables still hold on to their database sessions.
-  #   #So no confusion happens when passing variables around scopes.
-  #
-  #   DataMapper.database(:second_database) do
-  #
-  #     animal = Animal.first
-  #
-  #     DataMapper.database(:default) do
-  #       Animal.new(animal).save
-  #     end # :default database
-  #
-  #   end # :second_database
-  class Database
-    
-    @databases = {}
-    
-    # Allows you to access any of the named databases you have already setup.
-    #
-    #   default_db = DataMapper::Database[:default]
-    #   second_db = DataMapper::Database[:second_database]
-    def self.[](name)
-      @databases[name]
-    end
-    
-    # Returns the array of Database sessions currently being used
-    #
-    # This is what gives us thread safety, boys and girls
-    def self.context
-      Thread::current[:database_contexts] || Thread::current[:database_contexts] = []
-    end
-    
-    # Setup creates a database and sets all of your properties for that database.
-    # Setup looks for either a hash of options passed in to the database or a symbolized name
-    # for your database, as well as it's hash of parameters
-    #
-    # If no options are passed, an ArgumentException will be raised.
-    #   
-    #   DataMapper::Database.setup(name = :default, options_hash)
-    #
-    #   DataMapper::Database.setup({
-    #    :adapter  => 'mysql'
-    #    :host     => 'localhost'
-    #    :username => 'root'
-    #    :password => 'R00tPaswooooord'
-    #    :database => 'selecta_development'
-    #   })
-    #
-    #
-    #   DataMapper::Database.setup(:named_database, {
-    #    :adapter  => 'mysql'
-    #    :host     => 'localhost'
-    #    :username => 'root'
-    #    :password => 'R00tPaswooooord'
-    #    :database => 'selecta_development'
-    #   })
-    
-    def self.setup(*args)
-      
-      name, options = nil
-      
-      if (args.nil?) || (args[1].nil? && args[0].class != Hash)
-        raise ArgumentError.new('Database cannot be setup without at least an options hash.')
-      end
-      
-      if args.size == 1
-        name, options = :default, args[0]
-      elsif args.size == 2
-        name, options = args[0], args[1]
-      end        
-      
-      current = self.new(name)
-      
-      current.single_threaded = false if options[:single_threaded] == false
-      
-      options.each_pair do |k,v|
-        current.send("#{k}=", v)
-      end
-      
-      @databases[name] = current
-    end
-    
-    # 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, :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 = ''
-      @socket = nil
-      
-      @log_level = Logger::WARN
-      @log_stream = nil
-    end
-    
-    attr_reader :name, :adapter, :log_stream
-    
-    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)
-    end
-    
-    # Allows us to set the adapter for this database object. It can only be set once, and expects two types of values.
-    #
-    # You may pass in either a class inheriting from DataMapper::Adapters::AbstractAdapter
-    # or pass in a string indicating the type of adapter you would like to use.
-    #
-    # To create your own adapters, create a file in data_mapper/adapters/new_adapter.rb that inherits from AbstractAdapter
-    #
-    #   database.adapter=("postgresql")
-    def adapter=(value)
-      if @adapter
-        raise ArgumentError.new('The adapter is readonly after being set')
-      end
-      
-      if value.is_a?(DataMapper::Adapters::AbstractAdapter)
-        @adapter = value
-      elsif value.is_a?(Class)
-        @adapter = value.new(self)
-      else
-        begin
-          require "data_mapper/adapters/#{Inflector.underscore(value)}_adapter"
-        rescue LoadError
-          require "#{Inflector.underscore(value)}_adapter"
-        end
-        adapter_class = Adapters::const_get(Inflector.classify(value) + "Adapter")
-      
-        @adapter = adapter_class.new(self)
-      end
-    end
-    
-    # Default Logger from Ruby's logger.rb
-    def logger
-      @logger = create_logger
-    
-      class << self
-        attr_reader :logger
-      end
-    
-      return @logger
-    end
-    
-    def create_logger
-      x = Logger.new(@log_stream, File::WRONLY | File::APPEND | File::CREAT)
-      x.level = @log_level
-      at_exit { x.close }
-      return x
-    end
-  end
-  
-end

data/lib/data_mapper/dependency_queue.rb

@@ -1,28 +0,0 @@
-module DataMapper
-  class DependencyQueue
-    
-    def initialize
-      @dependencies = Hash.new { |h,k| h[k] = [] }
-    end
-    
-    def add(class_name, &b)
-      @dependencies[class_name] << b
-      resolve!
-    end
-    
-    def resolve!
-      @dependencies.each_pair do |class_name, callbacks|
-        if Object.const_defined?(class_name)
-          klass = Object.const_get(class_name)
-
-          callbacks.each do |b|
-            b.call(klass)
-          end
-          
-          callbacks.clear
-        end
-      end
-    end
-    
-  end # class DependencyQueue
-end # module DataMapper

data/lib/data_mapper/embedded_value.rb

@@ -1,145 +0,0 @@
-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 = ''
-    end
-
-    def self.inherited(base)
-      base.const_set('EMBEDDED_PROPERTIES', [])
-    end
-    
-    # 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
-      
-      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, property) # :nodoc:
-
-      # add the method on the embedded class
-      class_eval <<-EOS
-        #{property.reader_visibility.to_s}
-        def #{name}
-          #{"@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 property.type == :boolean
-        class_eval("alias #{property.name}? #{property.name}")
-      end
-    end
-    
-    # define embedded property setters
-    def self.define_property_setter(name, property)  # :nodoc:
-
-      # add the method on the embedded class
-      class_eval <<-EOS
-        #{property.writer_visibility.to_s}
-        def #{name.to_s.sub(/\?$/, '')}=(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('::')
-        tree.pop
-        tree.inject(Object) { |klass, current| klass.const_get(current) }
-      end
-    end
-    
-    def self.define(container, name, options, &block)
-      embedded_class, embedded_class_name, accessor_name = nil
-
-      accessor_name = name.to_s
-      embedded_class_name = Inflector.camelize(accessor_name)
-      embedded_class = Class.new(EmbeddedValue)
-      container.const_set(embedded_class_name, embedded_class) unless container.const_defined?(embedded_class_name)
-
-      if options[:prefix]
-        container_prefix = options[:prefix].kind_of?(String) ? options[:prefix] : "#{accessor_name}_"
-        embedded_class.instance_variable_set('@container_prefix', container_prefix)
-      end
-
-      embedded_class.instance_variable_set('@containing_class', container)
-
-      embedded_class.instance_variable_set('@container_lazy', !!options[:lazy])
-      embedded_class.instance_variable_set('@container_reader_visibility', options[:reader] || options[:accessor] || :public)
-      embedded_class.instance_variable_set('@container_writer_visibility', options[:writer] || options[:accessor] || :public)
-
-      embedded_class.class_eval(&block) if block_given?
-
-      container.class_eval <<-EOS
-        def #{accessor_name}
-          #{embedded_class_name}.new(self)
-        end
-      EOS
-    end
-    
-  end
-  
-end # module DataMapper

data/lib/data_mapper/identity_map.rb

@@ -1,47 +0,0 @@
-module DataMapper
-  
-  # Tracks objects to help ensure that each object gets loaded only once.
-  # See: http://www.martinfowler.com/eaaCatalog/identityMap.html
-  class IdentityMap
-    
-    def initialize
-      # WeakHash is much more expensive, and not necessary if the IdentityMap is tied to Session instead of Database.
-      # @cache = Hash.new { |h,k| h[k] = Support::WeakHash.new }
-      @cache = Hash.new { |h,k| h[k] = Hash.new }
-    end
-
-    # Pass a Class and a key, and to retrieve an instance.
-    # If the instance isn't found, nil is returned.
-    def get(klass, key)
-      @cache[mapped_class(klass)][key]
-    end
-
-    # Pass an instance to add it to the IdentityMap.
-    # The instance must have an assigned key.
-    def set(instance)
-      instance_key = instance.key
-      raise "Can't store an instance with a nil key in the IdentityMap" if instance_key.nil?
-      
-      @cache[mapped_class(instance.class)][instance_key] = instance
-    end
-    
-    # Remove an instance from the IdentityMap.
-    def delete(instance)
-      @cache[mapped_class(instance.class)].delete(instance.key)
-    end
-    
-    # Clears a particular set of classes from the IdentityMap.
-    def clear!(klass)
-      @cache.delete(klass)
-    end
-    
-    private
-    def mapped_class(klass)
-      unless klass.superclass.respond_to?(:persistent?)
-        klass
-      else
-        mapped_class(klass.superclass)
-      end
-    end
-  end
-end