dm-core 0.9.11 → 0.10.0

data/lib/dm-core/adapters/postgres_adapter.rb

@@ -1,189 +1,23 @@
-gem 'do_postgres', '~>0.9.11'
+require DataMapper.root / 'lib' / 'dm-core' / 'adapters' / 'data_objects_adapter'
+
 require 'do_postgres'
 
 module DataMapper
   module Adapters
     class PostgresAdapter < DataObjectsAdapter
-      module SQL
+      module SQL #:nodoc:
         private
 
+        # TODO: document
+        # @api private
         def supports_returning?
           true
         end
       end #module SQL
 
       include SQL
-
-      # TODO: move to dm-more/dm-migrations (if possible)
-      module Migration
-        # TODO: move to dm-more/dm-migrations (if possible)
-        def storage_exists?(storage_name)
-          statement = <<-SQL.compress_lines
-            SELECT COUNT(*)
-            FROM "information_schema"."tables"
-            WHERE "table_type" = 'BASE TABLE'
-            AND "table_schema" = current_schema()
-            AND "table_name" = ?
-          SQL
-
-          query(statement, storage_name).first > 0
-        end
-
-        # TODO: move to dm-more/dm-migrations (if possible)
-        def field_exists?(storage_name, column_name)
-          statement = <<-SQL.compress_lines
-            SELECT COUNT(*)
-            FROM "information_schema"."columns"
-            WHERE "table_schema" = current_schema()
-            AND "table_name" = ?
-            AND "column_name" = ?
-          SQL
-
-          query(statement, storage_name, column_name).first > 0
-        end
-
-        # TODO: move to dm-more/dm-migrations
-        def upgrade_model_storage(repository, model)
-          add_sequences(repository, model)
-          super
-        end
-
-        # TODO: move to dm-more/dm-migrations
-        def create_model_storage(repository, model)
-          add_sequences(repository, model)
-          without_notices { super }
-        end
-
-        # TODO: move to dm-more/dm-migrations
-        def destroy_model_storage(repository, model)
-          return true unless storage_exists?(model.storage_name(repository.name))
-          success = without_notices { super }
-          model.properties(repository.name).each do |property|
-            drop_sequence(repository, property) if property.serial?
-          end
-          success
-        end
-
-        protected
-
-        # TODO: move to dm-more/dm-migrations
-        def create_sequence(repository, property)
-          return if sequence_exists?(repository, property)
-          execute(create_sequence_statement(repository, property))
-        end
-
-        # TODO: move to dm-more/dm-migrations
-        def drop_sequence(repository, property)
-          without_notices { execute(drop_sequence_statement(repository, property)) }
-        end
-
-        module SQL
-          private
-
-          # TODO: move to dm-more/dm-migrations
-          def drop_table_statement(repository, model)
-            "DROP TABLE #{quote_table_name(model.storage_name(repository.name))}"
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def without_notices
-            # execute the block with NOTICE messages disabled
-            begin
-              execute('SET client_min_messages = warning')
-              yield
-            ensure
-              execute('RESET client_min_messages')
-            end
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def add_sequences(repository, model)
-            model.properties(repository.name).each do |property|
-              create_sequence(repository, property) if property.serial?
-            end
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def sequence_name(repository, property)
-            "#{property.model.storage_name(repository.name)}_#{property.field(repository.name)}_seq"
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def sequence_exists?(repository, property)
-            statement = <<-EOS.compress_lines
-              SELECT COUNT(*)
-              FROM "information_schema"."sequences"
-              WHERE "sequence_name" = ?
-              AND "sequence_schema" = current_schema()
-            EOS
-
-            query(statement, sequence_name(repository, property)).first > 0
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def create_sequence_statement(repository, property)
-            "CREATE SEQUENCE #{quote_column_name(sequence_name(repository, property))}"
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def drop_sequence_statement(repository, property)
-            "DROP SEQUENCE IF EXISTS #{quote_column_name(sequence_name(repository, property))}"
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def property_schema_statement(schema)
-            statement = super
-
-            if schema.has_key?(:sequence_name)
-              statement << " DEFAULT nextval('#{schema[:sequence_name]}') NOT NULL"
-            end
-
-            statement
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def property_schema_hash(repository, property)
-            schema = super
-
-            if property.serial?
-              schema.delete(:default)  # the sequence will be the default
-              schema[:sequence_name] = sequence_name(repository, property)
-            end
-
-            # TODO: see if TypeMap can be updated to set specific attributes to nil
-            # for different adapters.  precision/scale are perfect examples for
-            # Postgres floats
-
-            # Postgres does not support precision and scale for Float
-            if property.primitive == Float
-              schema.delete(:precision)
-              schema.delete(:scale)
-            end
-
-            schema
-          end
-        end # module SQL
-
-        include SQL
-
-        module ClassMethods
-          # TypeMap for PostgreSQL databases.
-          #
-          # @return <DataMapper::TypeMap> default TypeMap for PostgreSQL databases.
-          #
-          # TODO: move to dm-more/dm-migrations
-          def type_map
-            @type_map ||= TypeMap.new(super) do |tm|
-              tm.map(DateTime).to('TIMESTAMP')
-              tm.map(Integer).to('INT4')
-              tm.map(Float).to('FLOAT8')
-            end
-          end
-        end # module ClassMethods
-      end # module Migration
-
-      include Migration
-      extend Migration::ClassMethods
     end # class PostgresAdapter
+
+    const_added(:PostgresAdapter)
   end # module Adapters
 end # module DataMapper

data/lib/dm-core/adapters/sqlite3_adapter.rb

@@ -1,105 +1,12 @@
-gem 'do_sqlite3', '~>0.9.11'
+require DataMapper.root / 'lib' / 'dm-core' / 'adapters' / 'data_objects_adapter'
+
 require 'do_sqlite3'
 
 module DataMapper
   module Adapters
     class Sqlite3Adapter < DataObjectsAdapter
-      module SQL
-        private
-
-        def quote_column_value(column_value)
-          case column_value
-            when TrueClass  then quote_column_value('t')
-            when FalseClass then quote_column_value('f')
-            else
-              super
-          end
-        end
-      end # module SQL
-
-      include SQL
-
-      # TODO: move to dm-more/dm-migrations (if possible)
-      module Migration
-        # TODO: move to dm-more/dm-migrations (if possible)
-        def storage_exists?(storage_name)
-          query_table(storage_name).size > 0
-        end
-
-        # TODO: move to dm-more/dm-migrations (if possible)
-        def field_exists?(storage_name, column_name)
-          query_table(storage_name).any? do |row|
-            row.name == column_name
-          end
-        end
-
-        private
-
-        # TODO: move to dm-more/dm-migrations (if possible)
-        def query_table(table_name)
-          query('PRAGMA table_info(?)', table_name)
-        end
-
-        module SQL
-#          private  ## This cannot be private for current migrations
-
-          # TODO: move to dm-more/dm-migrations
-          def supports_serial?
-            sqlite_version >= '3.1.0'
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def create_table_statement(repository, model)
-            statement = <<-EOS.compress_lines
-              CREATE TABLE #{quote_table_name(model.storage_name(repository.name))}
-              (#{model.properties_with_subclasses(repository.name).map { |p| property_schema_statement(property_schema_hash(repository, p)) } * ', '}
-            EOS
-
-            # skip adding the primary key if one of the columns is serial.  In
-            # SQLite the serial column must be the primary key, so it has already
-            # been defined
-            unless model.properties(repository.name).any? { |p| p.serial? }
-              if (key = model.properties(repository.name).key).any?
-                statement << ", PRIMARY KEY(#{key.map { |p| quote_column_name(p.field(repository.name)) } * ', '})"
-              end
-            end
-
-            statement << ')'
-            statement
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def property_schema_statement(schema)
-            statement = super
-            statement << ' PRIMARY KEY AUTOINCREMENT' if supports_serial? && schema[:serial?]
-            statement
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def sqlite_version
-            @sqlite_version ||= query('SELECT sqlite_version(*)').first
-          end
-        end # module SQL
-
-        include SQL
-
-        module ClassMethods
-          # TypeMap for SQLite 3 databases.
-          #
-          # @return <DataMapper::TypeMap> default TypeMap for SQLite 3 databases.
-          #
-          # TODO: move to dm-more/dm-migrations
-          def type_map
-            @type_map ||= TypeMap.new(super) do |tm|
-              tm.map(Integer).to('INTEGER')
-              tm.map(Class).to('VARCHAR')
-            end
-          end
-        end # module ClassMethods
-      end # module Migration
-
-      include Migration
-      extend Migration::ClassMethods
     end # class Sqlite3Adapter
+
+    const_added(:Sqlite3Adapter)
   end # module Adapters
 end # module DataMapper

data/lib/dm-core/adapters/yaml_adapter.rb

@@ -0,0 +1,116 @@
+require 'pathname'
+require 'yaml'
+
+module DataMapper
+  module Adapters
+    class YamlAdapter < AbstractAdapter
+      # TODO: document
+      # @api semipublic
+      def create(resources)
+        update_records(resources.first.model) do |records|
+          resources.each do |resource|
+            initialize_serial(resource, records.size.succ)
+            records << resource.attributes(:field)
+          end
+        end
+      end
+
+      # TODO: document
+      # @api semipublic
+      def read(query)
+        query.filter_records(records_for(query.model).dup)
+      end
+
+      # TODO: document
+      # @api semipublic
+      def update(attributes, collection)
+        attributes = attributes_as_fields(attributes)
+
+        update_records(collection.model) do |records|
+          records_to_update = collection.query.filter_records(records.dup)
+          records_to_update.each { |resource| resource.update(attributes) }.size
+        end
+      end
+
+      # TODO: document
+      # @api semipublic
+      def delete(collection)
+        update_records(collection.model) do |records|
+          records_to_delete = collection.query.filter_records(records.dup)
+          records.replace(records - records_to_delete)
+          records_to_delete.size
+        end
+      end
+
+      private
+
+      # TODO: document
+      # @api semipublic
+      def initialize(name, options = {})
+        super
+        (@path = Pathname(@options[:path]).freeze).mkpath
+      end
+
+      # Retrieves all records for a model and yeilds them to a block.
+      #
+      # The block should make any changes to the records in-place. After
+      # the block executes all the records are dumped back to the file.
+      #
+      # @param [Model, #to_s] model
+      #   Used to determine which file to read/write to
+      #
+      # @yieldparam [Hash]
+      #   A hash of record.key => record pairs retrieved from the file
+      #
+      # @api private
+      def update_records(model)
+        records = records_for(model)
+        result = yield records
+        write_records(model, records)
+        result
+      end
+
+      # Read all records from a file for a model
+      #
+      # @param [#storage_name] model
+      #   The model/name to retieve records for
+      #
+      # @api private
+      def records_for(model)
+        file = yaml_file(model)
+        file.readable? && YAML.load_file(file) || []
+      end
+
+      # Writes all records to a file
+      #
+      # @param [#storage_name] model
+      #   The model/name to write the records for
+      #
+      # @param [Hash] records
+      #   A hash of record.key => record pairs to be written
+      #
+      # @api private
+      def write_records(model, records)
+        yaml_file(model).open('w') do |fh|
+          YAML.dump(records, fh)
+        end
+      end
+
+      # Given a model, gives the filename to be used for record storage
+      #
+      # @example
+      #   yaml_file(Article) #=> "/path/to/files/articles.yml"
+      #
+      # @param [#storage_name] model
+      #   The model to be used to determine the file name.
+      #
+      # @api private
+      def yaml_file(model)
+        @path / "#{model.storage_name(name)}.yml"
+      end
+
+    end # class YamlAdapter
+
+    const_added(:YamlAdapter)
+  end # module Adapters
+end # module DataMapper

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

@@ -1,147 +1,429 @@
-require File.join(File.dirname(__FILE__), "one_to_many")
 module DataMapper
   module Associations
-    module ManyToMany
-      extend Assertions
+    module ManyToMany #:nodoc:
+      class Relationship < Associations::OneToMany::Relationship
+        extend Chainable
 
-      # Setup many to many 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
+        OPTIONS = superclass::OPTIONS.dup << :through << :via
 
-        repository_name = model.repository.name
+        # Returns a set of keys that identify the target model
+        #
+        # @return [DataMapper::PropertySet]
+        #   a set of properties that identify the target model
+        #
+        # @api semipublic
+        def child_key
+          return @child_key if defined?(@child_key)
 
-        model.class_eval <<-EOS, __FILE__, __LINE__
-          def #{name}(query = {})
-            #{name}_association.all(query)
+          repository_name = child_repository_name || parent_repository_name
+          properties      = child_model.properties(repository_name)
+
+          @child_key = if @child_properties
+            child_key = properties.values_at(*@child_properties)
+            properties.class.new(child_key).freeze
+          else
+            properties.key
+          end
+        end
+
+        # TODO: document
+        # @api semipublic
+        alias target_key child_key
+
+        # Intermediate association for through model
+        # relationships
+        #
+        # Example: for :bugs association in
+        #
+        # class Software::Engineer
+        #   include DataMapper::Resource
+        #
+        #   has n, :missing_tests
+        #   has n, :bugs, :through => :missing_tests
+        # end
+        #
+        # through is :missing_tests
+        #
+        # TODO: document a case when
+        # through option is a model and
+        # not an association name
+        #
+        # @api semipublic
+        def through
+          return @through if defined?(@through)
+
+          if options[:through].kind_of?(Associations::Relationship)
+            return @through = options[:through]
+          end
+
+          repository_name = source_repository_name
+          relationships   = source_model.relationships(repository_name)
+          name            = through_relationship_name
+
+          @through = relationships[name] ||
+            DataMapper.repository(repository_name) do
+              source_model.has(min..max, name, through_model, one_to_many_options)
+            end
+
+          @through.child_key
+
+          @through
+        end
+
+        # TODO: document
+        # @api semipublic
+        def via
+          return @via if defined?(@via)
+
+          if options[:via].kind_of?(Associations::Relationship)
+            return @via = options[:via]
+          end
+
+          repository_name = through.relative_target_repository_name
+          through_model   = through.target_model
+          relationships   = through_model.relationships(repository_name)
+          singular_name   = name.to_s.singularize.to_sym
+
+          @via = relationships[options[:via]] ||
+            relationships[name]               ||
+            relationships[singular_name]
+
+          @via ||= if anonymous_through_model?
+            DataMapper.repository(repository_name) do
+              through_model.belongs_to(singular_name, target_model, many_to_one_options)
+            end
+          else
+            raise UnknownRelationshipError, "No relationships named #{name} or #{singular_name} in #{through_model}"
           end
 
-          def #{name}=(children)
-            #{name}_association.replace(children)
+          @via.child_key
+
+          @via
+        end
+
+        # TODO: document
+        # @api semipublic
+        def links
+          return @links if defined?(@links)
+
+          @links = []
+          links  = [ through, via ]
+
+          while relationship = links.shift
+            if relationship.respond_to?(:links)
+              links.unshift(*relationship.links)
+            else
+              @links << relationship
+            end
           end
 
-          private
+          @links.freeze
+        end
+
+        # TODO: document
+        # @api private
+        def source_scope(source)
+          { through.inverse => source }
+        end
 
-          def #{name}_association
-            @#{name}_association ||= begin
-              unless relationship = model.relationships(#{repository_name.inspect})[#{name.inspect}]
-                raise ArgumentError, "Relationship #{name.inspect} does not exist in \#{model}"
+        # TODO: document
+        # @api private
+        def query
+          # TODO: consider making this a query_for method, so that ManyToMany::Relationship#query only
+          # returns the query supplied in the definition
+          @many_to_many_query ||= super.merge(:links => links).freeze
+        end
+
+        # Eager load the collection using the source as a base
+        #
+        # @param [Resource, Collection] source
+        #   the source to query with
+        # @param [Query, Hash] other_query
+        #   optional query to restrict the collection
+        #
+        # @return [ManyToMany::Collection]
+        #   the loaded collection for the source
+        #
+        # @api private
+        def eager_load(source, other_query = nil)
+          # FIXME: enable SEL for m:m relationships
+          source.model.all(query_for(source, other_query))
+        end
+
+        private
+
+        # TODO: document
+        # @api private
+        def through_model
+          namespace, name = through_model_namespace_name
+
+          if namespace.const_defined?(name)
+            namespace.const_get(name)
+          else
+            model = Model.new do
+              # all properties added to the anonymous through model are keys by default
+              def property(name, type, options = {})
+                options[:key] = true unless options.key?(:key)
+                options.delete(:index)
+                super
               end
-              association = Proxy.new(relationship, self)
-              parent_associations << association
-              association
             end
+
+            namespace.const_set(name, model)
           end
-        EOS
+        end
 
-        opts = options.dup
-        opts.delete(:through)
-        opts[:child_model]              ||= opts.delete(:class_name)  || Extlib::Inflection.classify(name)
-        opts[:parent_model]             =   model
-        opts[:repository_name]          =   repository_name
-        opts[:remote_relationship_name] ||= opts.delete(:remote_name) || Extlib::Inflection.tableize(opts[:child_model])
-        opts[:parent_key]               =   opts[:parent_key]
-        opts[:child_key]                =   opts[:child_key]
-        opts[:mutable]                  =   true
+        # TODO: document
+        # @api private
+        def through_model_namespace_name
+          target_parts = target_model.base_model.name.split('::')
+          source_parts = source_model.base_model.name.split('::')
 
-        names        = [ opts[:child_model], opts[:parent_model].name ].sort
-        model_name   = names.join.gsub("::", "")
-        storage_name = Extlib::Inflection.tableize(Extlib::Inflection.pluralize(names[0]) + names[1])
+          name = [ target_parts.pop, source_parts.pop ].sort.join
 
-        opts[:near_relationship_name] = Extlib::Inflection.tableize(model_name).to_sym
+          namespace = Object
 
-        model.has(model.n, opts[:near_relationship_name])
+          # find the common namespace between the target_model and source_model
+          target_parts.zip(source_parts) do |target_part, source_part|
+            break if target_part != source_part
+            namespace = namespace.const_get(target_part)
+          end
 
-        relationship = model.relationships(repository_name)[name] = RelationshipChain.new(opts)
+          return namespace, name
+        end
 
-        unless Object.const_defined?(model_name)
-          model = DataMapper::Model.new(storage_name)
+        # TODO: document
+        # @api private
+        def through_relationship_name
+          if anonymous_through_model?
+            namespace = through_model_namespace_name.first
+            relationship_name = Extlib::Inflection.underscore(through_model.name.sub(/\A#{namespace.name}::/, '')).tr('/', '_')
+            relationship_name.pluralize.to_sym
+          else
+            options[:through]
+          end
+        end
 
-          model.class_eval <<-EOS, __FILE__, __LINE__
-            def self.name; #{model_name.inspect} end
-            def self.default_repository_name; #{repository_name.inspect} end
-            def self.many_to_many; true end
-          EOS
+        # Check if the :through association uses an anonymous model
+        #
+        # An anonymous model means that DataMapper creates the model
+        # in-memory, and sets the relationships to join the source
+        # and the target model.
+        #
+        # @return [Boolean]
+        #   true if the through model is anonymous
+        #
+        # @api private
+        def anonymous_through_model?
+          options[:through] == Resource
+        end
 
-          names.each do |n|
-            model.belongs_to(Extlib::Inflection.underscore(n).gsub('/', '_').to_sym)
+        # TODO: document
+        # @api semipublic
+        chainable do
+          def many_to_one_options
+            { :parent_key => target_key.map { |property| property.name } }
           end
+        end
 
-          Object.const_set(model_name, model)
+        # TODO: document
+        # @api semipublic
+        chainable do
+          def one_to_many_options
+            { :parent_key => source_key.map { |property| property.name } }
+          end
         end
 
-        relationship
-      end
+        # Returns the inverse relationship class
+        #
+        # @api private
+        def inverse_class
+          self.class
+        end
 
-      class Proxy < DataMapper::Associations::OneToMany::Proxy
-        def delete(resource)
-          through = near_association.get(*(@parent.key + resource.key))
-          near_association.delete(through)
-          orphan_resource(super)
+        # TODO: document
+        # @api private
+        def invert
+          inverse_class.new(inverse_name, parent_model, child_model, inverted_options)
         end
 
-        def clear
-          near_association.clear
-          super
+        # TODO: document
+        # @api private
+        def inverted_options
+          links   = self.links.dup
+          through = links.pop.inverse
+
+          links.reverse_each do |relationship|
+            inverse = relationship.inverse
+
+            through = self.class.new(
+              inverse.name,
+              inverse.child_model,
+              inverse.parent_model,
+              inverse.options.merge(:through => through)
+            )
+          end
+
+          options.only(*OPTIONS - [ :min, :max ]).update(
+            :through    => through,
+            :child_key  => options[:parent_key],
+            :parent_key => options[:child_key],
+            :inverse    => self
+          )
+        end
+
+        # Loads association targets and sets resulting value on
+        # given source resource
+        #
+        # @param [Resource] source
+        #   the source resource for the association
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def lazy_load(source)
+          # FIXME: delegate to super once SEL is enabled
+          set!(source, collection_for(source))
         end
 
+        # Returns collection class used by this type of
+        # relationship
+        #
+        # @api private
+        def collection_class
+          ManyToMany::Collection
+        end
+      end # class Relationship
+
+      class Collection < Associations::OneToMany::Collection
+        # Remove every Resource in the m:m Collection from the repository
+        #
+        # This performs a deletion of each Resource in the Collection from
+        # the repository and clears the Collection.
+        #
+        # @return [Boolean]
+        #   true if the resources were successfully destroyed
+        #
+        # @api public
         def destroy
-          near_association.destroy
+          assert_source_saved 'The source must be saved before mass-deleting the collection'
+
+          # make sure the records are loaded so they can be found when
+          # the intermediaries are removed
+          lazy_load
+
+          unless intermediaries.destroy
+            return false
+          end
+
           super
         end
 
-        def save
+        # Remove every Resource in the m:m Collection from the repository, bypassing validation
+        #
+        # This performs a deletion of each Resource in the Collection from
+        # the repository and clears the Collection while skipping
+        # validation.
+        #
+        # @return [Boolean]
+        #   true if the resources were successfully destroyed
+        #
+        # @api public
+        def destroy!
+          assert_source_saved 'The source must be saved before mass-deleting the collection'
+
+          # make sure the records are loaded so they can be found when
+          # the intermediaries are removed
+          lazy_load
+
+          unless intermediaries.destroy!
+            return false
+          end
+
+          super
         end
 
         private
 
-        def new_child(attributes)
-          remote_relationship.parent_model.new(attributes)
+        # TODO: document
+        # @api private
+        def _create(safe, attributes)
+          if via.respond_to?(:resource_for)
+            resource = super
+            if create_intermediary(safe, via => resource)
+              resource
+            end
+          else
+            if intermediary = create_intermediary(safe)
+              super(safe, attributes.merge(via.inverse => intermediary))
+            end
+          end
         end
 
-        def relate_resource(resource)
-          assert_mutable
-          add_default_association_values(resource)
-          @orphans.delete(resource)
+        # TODO: document
+        # @api private
+        def _save(safe)
+          # delete only intermediaries linked to the removed targets
+          unless @removed.empty? || intermediaries(@removed).send(safe ? :destroy : :destroy!)
+            return false
+          end
 
-          # TODO: fix this so it does not automatically save on append, if possible
-          resource.save if resource.new_record?
-          through_resource = @relationship.child_model.new
-          @relationship.child_key.zip(@relationship.parent_key) do |child_key,parent_key|
-            through_resource.send("#{child_key.name}=", parent_key.get(@parent))
+          if via.respond_to?(:resource_for)
+            super
+            loaded_entries.all? { |resource| create_intermediary(safe, via => resource) }
+          else
+            if intermediary = create_intermediary(safe)
+              inverse = via.inverse
+              loaded_entries.map { |resource| inverse.set(resource, intermediary) }
+            end
+
+            super
           end
-          remote_relationship.child_key.zip(remote_relationship.parent_key) do |child_key,parent_key|
-            through_resource.send("#{child_key.name}=", parent_key.get(resource))
+        end
+
+        # TODO: document
+        # @api private
+        def intermediaries(targets = self)
+          intermediaries = if through.loaded?(source)
+            through.get!(source)
+          else
+            through.set!(source, through.collection_for(source))
           end
-          near_association << through_resource
 
-          resource
+          intermediaries.all(via => targets)
         end
 
-        def orphan_resource(resource)
-          assert_mutable
-          @orphans << resource
-          resource
-        end
+        # TODO: document
+        # @api private
+        def create_intermediary(safe, attributes = {})
+          collection = intermediaries
+
+          return unless collection.send(safe ? :save : :save!)
+
+          intermediary = collection.first(attributes) ||
+                         collection.send(safe ? :create : :create!, attributes)
 
-        def assert_mutable
+          return intermediary if intermediary.saved?
         end
 
-        def remote_relationship
-          @remote_relationship ||= @relationship.send(:remote_relationship)
+        # TODO: document
+        # @api private
+        def through
+          relationship.through
         end
 
-        def near_association
-          @near_association ||= @parent.send(near_relationship_name)
+        # TODO: document
+        # @api private
+        def via
+          relationship.via
         end
 
-        def near_relationship_name
-          @near_relationship_name ||= @relationship.send(:instance_variable_get, :@near_relationship_name)
+        # TODO: document
+        # @api private
+        def inverse_set(*)
+          # do nothing
         end
-      end # class Proxy
+      end # class Collection
     end # module ManyToMany
   end # module Associations
 end # module DataMapper