datamapper 0.1.0

data/lib/data_mapper/associations/has_one_association.rb

@@ -0,0 +1,107 @@
+module DataMapper
+  module Associations
+    
+    class HasOneAssociation
+      
+      def initialize(instance, association_name, options)
+        @instance = instance
+        @association_name = association_name
+        @options = options
+        
+        @associated_class = if options.has_key?(:class) || options.has_key?(:class_name)
+          associated_class_name = (options[:class] || options[:class_name])
+          if associated_class_name.kind_of?(String)
+            Kernel.const_get(Inflector.classify(associated_class_name))
+          else
+            associated_class_name
+          end
+        else            
+          Kernel.const_get(Inflector.classify(association_name))
+        end
+      end
+      
+      def self.setup(klass, association_name, options)
+        
+        # Define the association instance method (i.e. Exhibit#zoo)
+        klass.class_eval <<-EOS
+          def create_#{association_name}(options = {})
+            #{association_name}_association.create(options)
+          end
+          
+          def build_#{association_name}(options = {})
+            #{association_name}_association.build(options)
+          end
+
+          def #{association_name}
+            # Let the HasOneAssociation do the finding, just to keep things neat around here...
+            #{association_name}_association.find
+          end
+          
+          def #{association_name}=(value)
+            #{association_name}_association.set(value)
+          end
+          
+          private
+            def #{association_name}_association
+              @#{association_name} || (@#{association_name} = HasOneAssociation.new(self, "#{association_name}", #{options.inspect}))
+            end
+        EOS
+        
+      end
+      
+      def find
+        return @result unless @result.nil?
+        
+        unless @instance.loaded_set.nil?
+          
+          # Temp variable for the instance variable name.
+          setter_method = "#{@association_name}=".to_sym
+          instance_variable_name = "@#{foreign_key}".to_sym
+          
+          set = @instance.loaded_set.instances.group_by { |instance| instance.key }
+          
+          # Fetch the foreign objects for all instances in the current object's loaded-set.
+          @instance.session.find(@associated_class, :all, foreign_key => set.keys).each do |association|
+            set[association.instance_variable_get(instance_variable_name)].first.send(setter_method, association)
+          end
+        end
+        
+        return @result
+      end
+
+      def create(options = {})
+        associated = @associated_class.new(options)
+        if associated.save
+          @instance.send("#{@associated_class.foreign_key}=", associated.id)
+          @result = associated
+        end
+      end
+      
+      def build(options = {})
+        @result = @associated_class.new(options)
+      end
+      
+      def set(val)
+        @result = val
+      end
+      
+      def foreign_key
+        @foreign_key ||= (@options[:foreign_key] || @instance.session.mappings[@instance.class].default_foreign_key)
+      end
+            
+    end
+    
+    module HasOne
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def has_one(association_name, options = {})
+          HasOneAssociation.setup(self, association_name, options)
+        end
+      end
+    end
+    
+  end
+end

data/lib/data_mapper/base.rb

@@ -0,0 +1,160 @@
+require 'data_mapper/unit_of_work'
+require 'data_mapper/extensions/active_record_impersonation'
+require 'data_mapper/extensions/callback_helpers'
+require 'data_mapper/validations/validation_helper'
+require 'data_mapper/associations'
+
+module DataMapper
+  
+  class Base
+    
+    # This probably needs to be protected
+    attr_accessor :loaded_set
+    
+    include UnitOfWork
+    include Extensions::ActiveRecordImpersonation
+    include Extensions::CallbackHelpers
+    include Extensions::ValidationHelper
+    include Associations
+    
+    def self.inherited(klass)
+      klass.send(:undef_method, :id)
+      
+      # When this class is sub-classed, copy the declared columns.
+      klass.class_eval do
+        def self.inherited(subclass)
+          
+          database.schema[subclass.superclass].columns.each do |c|
+            subclass.property(c.name, c.type, c.options)
+            subclass.before_create do
+              @type = self.class
+            end if c.name == :type
+          end
+          
+        end
+      end
+    end
+    
+    def self.set_table_name(value)
+      database.schema[self].name = value
+    end
+    
+    def initialize(details = nil)
+      
+      unless details.nil?
+        details.reject do |key, value|
+          protected_attribute? key
+        end.each_pair do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+    end
+    
+    def self.property(name, type, options = {})
+      mapping = database.schema[self].add_column(name, type, options)
+      property_getter(name, mapping)
+      property_setter(name, mapping)
+      return name
+    end
+    
+    def self.property_getter(name, mapping)
+      if mapping.lazy?
+        class_eval <<-EOS
+          def #{name}
+            lazy_load!("#{name}")
+          end
+        EOS
+      else
+        class_eval("def #{name}; #{mapping.instance_variable_name} end")
+      end
+    end
+    
+    def self.property_setter(name, mapping)
+      if mapping.lazy?
+        class_eval <<-EOS
+          def #{name.to_s.sub(/\?$/, '')}=(value)
+            class << self;
+              attr_accessor #{name.inspect}
+            end
+            @#{name} = value
+          end
+        EOS
+      else
+        class_eval("def #{name.to_s.sub(/\?$/, '')}=(value); #{mapping.instance_variable_name} = value end")
+      end
+    end
+    
+    def lazy_load!(name)
+      (class << self; self end).send(:attr_accessor, name)
+      
+      column = session.schema[self.class][name.to_sym]
+      
+      # If the value is already loaded, then we don't need to do it again.
+      value = instance_variable_get(column.instance_variable_name)
+      return value unless value.nil?
+      
+      session.find(self.class, :all, :select => [:id, name], :reload => true, :id => loaded_set.instances.map(&:id)).each do |instance|
+        (class << self; self end).send(:attr_accessor, name)
+      end
+      
+      instance_variable_get(column.instance_variable_name)
+    end
+        
+    def attributes
+      session.schema[self.class].columns.inject({}) do |values, column|
+        values[column.name] = instance_variable_get(column.instance_variable_name); values
+      end
+    end
+    
+    def attributes=(values_hash)
+      values_hash.reject do |key, value|
+        protected_attribute? key
+      end.each_pair do |key, value|
+        symbolic_instance_variable_set(key, value)
+      end
+    end
+    
+    def protected_attribute?(key)
+      self.class.protected_attributes.include?(key.kind_of?(Symbol) ? key : key.to_sym)
+    end
+    
+    def self.protected_attributes
+      @protected_attributes ||= []
+    end
+    
+    def self.protect(*keys)
+      keys.each { |key| protected_attributes << key.to_sym }
+    end
+    
+    def self.foreign_key
+      Inflector.underscore(self.name) + "_id"
+    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 session=(value)
+      @session = value
+    end
+    
+    def session
+      @session ||= database
+    end
+    
+    def key
+      key_column = session.schema[self.class].key
+      key_column.type_cast_value(instance_variable_get(key_column.instance_variable_name))
+    end
+        
+  end
+  
+end

data/lib/data_mapper/callbacks.rb

@@ -0,0 +1,47 @@
+module DataMapper
+  
+  class Callbacks
+  
+    EVENTS = [
+      :before_materialize, :after_materialize,
+      :before_save, :after_save,
+      :before_create, :after_create,
+      :before_update, :after_update,
+      :before_destroy, :after_destroy,
+      :before_validate, :after_validate
+      ]
+      
+    def initialize
+      @callbacks = Hash.new { |h,k| h[k.to_sym] = [] }
+    end
+    
+    alias ruby_method_missing method_missing
+    def method_missing(sym, *args)
+      if EVENTS.include?(sym)
+        self.class.send(:define_method, sym) { @callbacks[sym] }
+        return send(sym)
+      elsif sym.to_s =~ /^execute_(\w+)/ && EVENTS.include?($1.to_sym)
+        return execute(args.first, $1.to_sym)
+      end
+      
+      super
+    end
+    
+    def execute(name, instance)
+      @callbacks[name].each do |callback|
+        if callback.kind_of?(String)
+          instance.instance_eval(callback)
+        else
+          instance.instance_eval(&callback)
+        end
+      end
+    end
+    
+    def add(name, string = nil, &block)
+      callback = send(name)
+      raise ArgumentError.new("You didn't specify a callback in either string or block form.") if string.nil? && block.nil?
+      callback << (string.nil? ? block : string)
+    end
+  end
+  
+end

data/lib/data_mapper/database.rb

@@ -0,0 +1,134 @@
+require 'logger'
+require 'data_mapper/session'
+require 'data_mapper/mappings/schema'
+
+# 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.
+  # Non-Block Syntax:
+  #   Returns the current session, or if there is none,
+  #   a new Session.
+  def self.database(name = :default)
+    unless block_given?
+      Database.context.last || Session.new(Database[name])
+    else
+      Database.context.push(Session.new(Database[name]))
+      yield Database.context.last
+      Database.context.pop
+    end
+  end
+  
+  class DatabaseError < StandardError
+    attr_accessor :options
+  end
+  
+  class Database
+    
+    @databases = {}
+    @context = []
+    
+    def self.[](name)
+      @databases[name]
+    end
+    
+    def self.context
+      @context
+    end
+    
+    def self.setup(name = :default, &initializer)
+      current = self.new(name)
+      current.instance_eval(&initializer)
+      @databases[name] = current
+    end
+    
+    def initialize(name)
+      @name = name
+    end 
+    
+    # Shortcut to adapter.class::Queries::FooStatement.new
+    def method_missing(sym, *args)
+      return super if sym.to_s !~ /_statement$/
+      @adapter.class::Queries.const_get(Inflector.classify(sym.to_s)).new(self, *args)
+    end
+    
+    def syntax(token)
+      @adapter.class::SYNTAX[token]
+    end
+    
+    def [](klass_or_table_name)
+      schema[klass_or_table_name]
+    end
+    
+    def schema
+      @schema ||= Mappings::Schema.new(self)
+    end
+    
+    class ConditionEscapeError < StandardError; end
+    
+    attr_reader :name
+    
+    def adapter(value = nil)
+      return @adapter if value.nil?
+      
+      raise ArgumentError.new('The adapter is readonly after being set') unless @adapter.nil?
+      
+      require "data_mapper/adapters/#{Inflector.underscore(value)}_adapter"
+      adapter_class = Adapters::const_get(Inflector.classify(value) + "Adapter")
+      
+      (class << self; self end).send(:include, adapter_class::Quoting)
+      (class << self; self end).send(:include, adapter_class::Coersion)
+      
+      @adapter = adapter_class.new(self)
+    end
+    
+    def host(value = nil); value.nil? ? (@host || 'localhost') : @host = value end
+    def database(value = nil); value.nil? ? @database : @database = value end
+    def username(value = nil); value.nil? ? @username : @username = value end
+    def password(value = nil); value.nil? ? (@password || '') : @password = value end
+    
+    def log(value = nil)
+      @log = value unless value.nil?
+
+      if @log.nil?
+        @log = log_stream.nil? ? Logger.new(nil) : Logger.new(log_stream, File::WRONLY | File::APPEND | File::CREAT)
+        @log.level = log_level || Logger::WARN
+        at_exit { @log.close }
+      end
+      
+      @log
+    end
+    
+    def log_level(value = nil)
+      return @log_level if value.nil?
+      @log_level = value
+    end
+    
+    def log_stream(value = nil)
+      return @log_stream if value.nil?
+      @log_stream = value
+    end
+    
+    def connection
+      @adapter.connection do |db|
+        results = yield(db)
+      end
+    end
+    
+    def query(sql)
+      connection { |db| db.query(sql) }
+    end
+    
+    def execute(sql)
+      connection { |db| db.execute(sql) }
+    end
+  end
+  
+end