datamapper-dm-core 0.9.11 → 0.10.0

data/lib/dm-core/associations/one_to_one.rb

@@ -1,61 +1,74 @@
 module DataMapper
   module Associations
-    module OneToOne
-      extend Assertions
-
-      # Setup one to one relationship between two models
-      # -
-      # @api private
-      def self.setup(name, model, options = {})
-        assert_kind_of 'name',    name,    Symbol
-        assert_kind_of 'model',   model,   Model
-        assert_kind_of 'options', options, Hash
-
-        repository_name = model.repository.name
-
-        model.class_eval <<-EOS, __FILE__, __LINE__
-          def #{name}
-            #{name}_association.first
+    module OneToOne #:nodoc:
+      class Relationship < Associations::Relationship
+        %w[ public protected private ].map do |visibility|
+          superclass.send("#{visibility}_instance_methods", false).each do |method|
+            undef_method method unless method.to_s == 'initialize'
           end
+        end
 
-          def #{name}=(child_resource)
-            #{name}_association.replace(child_resource.nil? ? [] : [ child_resource ])
-          end
+        # Loads (if necessary) and returns association target
+        # for given source
+        #
+        # @api semipublic
+        def get(source, other_query = nil)
+          assert_kind_of 'source', source, source_model
 
-          private
-
-          def #{name}_association
-            @#{name}_association ||= begin
-              unless relationship = model.relationships(#{repository_name.inspect})[:#{name}]
-                raise ArgumentError, "Relationship #{name.inspect} does not exist in \#{model}"
-              end
-              association = Associations::OneToMany::Proxy.new(relationship, self)
-              parent_associations << association
-              association
-            end
-          end
-        EOS
-
-        model.relationships(repository_name)[name] = if options.has_key?(:through)
-          RelationshipChain.new(
-            :child_model              => options.fetch(:class_name, Extlib::Inflection.classify(name)),
-            :parent_model             => model,
-            :repository_name          => repository_name,
-            :near_relationship_name   => options[:through],
-            :remote_relationship_name => options.fetch(:remote_name, name),
-            :parent_key               => options[:parent_key],
-            :child_key                => options[:child_key]
-          )
-        else
-          Relationship.new(
-            name,
-            repository_name,
-            options.fetch(:class_name, Extlib::Inflection.classify(name)),
-            model,
-            options
-          )
-        end
-      end
+          return unless loaded?(source) || source_key.get(source).all?
+
+          relationship.get(source, other_query).first
+        end
+
+        # Sets and returns association target
+        # for given source
+        #
+        # @api semipublic
+        def set(source, target)
+          assert_kind_of 'source', source, source_model
+          assert_kind_of 'target', target, target_model, Hash, NilClass
+
+          relationship.set(source, [ target ].compact).first
+        end
+
+        # TODO: document
+        # @api public
+        def kind_of?(klass)
+          super || relationship.kind_of?(klass)
+        end
+
+        # TODO: document
+        # @api public
+        def instance_of?(klass)
+          super || relationship.instance_of?(klass)
+        end
+
+        # TODO: document
+        # @api public
+        def respond_to?(method, include_private = false)
+          super || relationship.respond_to?(method, include_private)
+        end
+
+        private
+
+        attr_reader :relationship
+
+        # Initializes the relationship. Always assumes target model class is
+        # a camel cased association name.
+        #
+        # @api semipublic
+        def initialize(name, target_model, source_model, options = {})
+          klass = options.key?(:through) ? ManyToMany::Relationship : OneToMany::Relationship
+          target_model ||= Extlib::Inflection.camelize(name).freeze
+          @relationship = klass.new(name, target_model, source_model, options)
+        end
+
+        # TODO: document
+        # @api private
+        def method_missing(method, *args, &block)
+          relationship.send(method, *args, &block)
+        end
+      end # class Relationship
     end # module HasOne
   end # module Associations
 end # module DataMapper