terrestrial 0.1.1 → 0.3.0

data/lib/terrestrial/graph_serializer.rb

@@ -1,6 +1,3 @@
-require "terrestrial/upserted_record"
-require "terrestrial/deleted_record"
-
 module Terrestrial
   class GraphSerializer
     def initialize(mappings:)
@@ -34,53 +31,63 @@ module Terrestrial
     private
 
     def associated_records(mapping, current_record, association_fields, depth)
-      mapping.associations
+      mapping
+        .associations
         .map { |name, association|
-          [association_fields.fetch(name), association]
-        }
-        .map { |collection, association|
-          [nodes(collection), deleted_nodes(collection), association]
+          dump_association(
+            association,
+            current_record,
+            association_fields.fetch(name),
+            depth,
+          )
         }
-        .map { |nodes, deleted_nodes, association|
-          association.dump(current_record, nodes, depth) { |assoc_mapping_name, assoc_object, foreign_key, assoc_depth|
-            call(assoc_mapping_name, assoc_object, assoc_depth, foreign_key).tap { |associated_record, *_join_records|
-              # TODO: remove this mutation
-              current_record.merge!(association.extract_foreign_key(associated_record))
-            }
-          } +
-          association.delete(current_record, deleted_nodes, depth) { |assoc_mapping_name, assoc_object, foreign_key, assoc_depth|
-            delete(assoc_mapping_name, assoc_object, assoc_depth, foreign_key)
-          }
+    end
+
+    def dump_association(association, current_record, collection, depth)
+      updated_nodes_recursive(association, current_record, collection, depth) + 
+        deleted_nodes(association, current_record, collection, depth)
+    end
+
+    def updated_nodes_recursive(association, current_record, collection, depth)
+      association.dump(current_record, get_loaded(collection), depth) { |assoc_mapping_name, assoc_object, pass_down_foreign_key, assoc_depth|
+        recurse(current_record, association, assoc_mapping_name, assoc_object, assoc_depth, pass_down_foreign_key)
+      }
+    end
+
+    def recurse(current_record, association, assoc_mapping_name, assoc_object, assoc_depth, foreign_key)
+      (assoc_object && call(assoc_mapping_name, assoc_object, assoc_depth, foreign_key))
+        .tap { |associated_record, *_join_records|
+          current_record.merge!(association.extract_foreign_key(associated_record))
         }
     end
 
+    def deleted_nodes(association, current_record, collection, depth)
+      nodes = get_deleted(collection)
+      association.delete(current_record, nodes, depth) { |assoc_mapping_name, assoc_object, foreign_key, assoc_depth|
+        delete(assoc_mapping_name, assoc_object, assoc_depth, foreign_key)
+      }
+    end
+
     def delete(mapping_name, object, depth, _foreign_key)
       mapping = mappings.fetch(mapping_name)
-      serialized_record = mapping.serializer.call(object)
-
-      [
-        DeletedRecord.new(
-          mapping.namespace,
-          mapping.primary_key,
-          serialized_record,
-          depth,
-        )
-      ]
+      mapping.delete(object, depth)
     end
 
-    def nodes(collection)
+    def get_loaded(collection)
       if collection.respond_to?(:each_loaded)
         collection.each_loaded
       elsif collection.is_a?(Struct)
         [collection]
       elsif collection.respond_to?(:each)
         collection.each
+      elsif collection.nil?
+        [nil]
       else
         [collection]
       end
     end
 
-    def deleted_nodes(collection)
+    def get_deleted(collection)
       if collection.respond_to?(:each_deleted)
         collection.each_deleted
       else

data/lib/terrestrial/inspection_string.rb

@@ -0,0 +1,19 @@
+module Terrestrial
+  module InspectionString
+    def inspect
+      (
+        ["\#<#{self.class.name}:0x#{sprintf("%014x", (object_id.<<(1)))}"] +
+        inspectable_properties.map { |name|
+          [
+            name,
+            instance_variable_get("@#{name}").inspect
+          ].join("=")
+        }
+      ).join(" ") + ">"
+    end
+
+    private def inspectable_properties
+      []
+    end
+  end
+end

data/lib/terrestrial/lazy_collection.rb

@@ -1,8 +1,8 @@
-require "terrestrial/short_inspection_string"
+require "terrestrial/inspection_string"
 
 module Terrestrial
   class LazyCollection
-    include ShortInspectionString
+    include InspectionString
     include Enumerable
 
     def initialize(database_enum, loader, queries)

data/lib/terrestrial/lazy_object_proxy.rb

@@ -1,6 +1,6 @@
 module Terrestrial
   class LazyObjectProxy
-    include ShortInspectionString
+    include InspectionString
 
     def initialize(object_loader, key_fields)
       @object_loader = object_loader

data/lib/terrestrial/many_to_one_association.rb

@@ -19,13 +19,13 @@ module Terrestrial
     private     :foreign_key, :key, :proxy_factory
 
     def build_proxy(data_superset:, loader:, record:)
-      proxy_factory.call(
-        query: build_query(data_superset, record),
-        loader: loader,
-        preloaded_data: {
-          key => foreign_key_value(record),
-        },
-      )
+      foreign_key_nil?(record) ? nil : proxy_factory.call(
+          query: build_query(data_superset, record),
+          loader: loader,
+          preloaded_data: {
+            key => foreign_key_value(record),
+          },
+        )
     end
 
     def eager_superset((superset), (associated_dataset))
@@ -41,20 +41,26 @@ module Terrestrial
     end
 
     def dump(parent_record, collection, depth, &block)
-      collection.flat_map { |object|
-        block.call(mapping_name, object, _foreign_key_does_not_go_here = {}, depth + depth_modifier)
-      }
+      collection
+        .flat_map { |object|
+          block.call(mapping_name, object, _foreign_key_does_not_go_here = {}, depth + depth_modifier)
+        }
+        .reject(&:nil?)
     end
     alias_method :delete, :dump
 
     def extract_foreign_key(record)
       {
-        foreign_key => record.fetch(key),
+        foreign_key => (record && record.fetch(key)),
       }
     end
 
     private
 
+    def foreign_key_nil?(record)
+      foreign_key_value(record).nil?
+    end
+
     def foreign_key_value(record)
       record.fetch(foreign_key)
     end

data/lib/terrestrial/public_conveniencies.rb

@@ -1,23 +1,48 @@
 require "terrestrial/identity_map"
 require "terrestrial/dirty_map"
 require "terrestrial/upserted_record"
-require "terrestrial/mapper_facade"
+require "terrestrial/relational_store"
 require "terrestrial/configurations/conventional_configuration"
+require "terrestrial/inspection_string"
 
 module Terrestrial
+  class ObjectStore
+    include Fetchable
+    include InspectionString
+
+    def initialize(stores)
+      @mappings = stores.keys
+      @stores = stores
+    end
+
+    def [](mapping_name)
+      @stores[mapping_name]
+    end
+
+    def from(mapping_name)
+      fetch(mapping_name)
+    end
+
+    private
+
+    def inspectable_properties
+      [ :mappings ]
+    end
+  end
+
   module PublicConveniencies
     def config(database_connection)
       Configurations::ConventionalConfiguration.new(database_connection)
     end
 
-    def mappers(mappings:, datastore:)
-      dirty_map = build_dirty_map
-      identity_map = build_identity_map
+    def object_store(mappings:, datastore:)
+      dirty_map = Private.build_dirty_map
+      identity_map = Private.build_identity_map
 
-      Hash[mappings.map { |name, _mapping|
+      stores = Hash[mappings.map { |name, _mapping|
         [
           name,
-          mapper(
+          Private.single_type_store(
             mappings: mappings ,
             name: name,
             datastore: datastore,
@@ -26,114 +51,119 @@ module Terrestrial
           )
         ]
       }]
-    end
-
-    private
 
-    def mapper(mappings:, name:, datastore:, identity_map:, dirty_map:)
-      dataset = datastore[mappings.fetch(name).namespace]
-
-      MapperFacade.new(
-        mappings: mappings,
-        mapping_name: name,
-        datastore: datastore,
-        dataset: dataset,
-        load_pipeline: build_load_pipeline(
-          dirty_map: dirty_map,
-          identity_map: identity_map,
-        ),
-        dump_pipeline: build_dump_pipeline(
-          dirty_map: dirty_map,
-          transaction: datastore.method(:transaction),
-          upsert: method(:upsert_record).curry.call(datastore),
-          delete: method(:delete_record).curry.call(datastore),
-        )
-      )
+      ObjectStore.new(stores)
     end
 
-    private
+    module Private
+      module_function
 
-    def build_identity_map(storage = {})
-      IdentityMap.new(storage)
-    end
+      def single_type_store(mappings:, name:, datastore:, identity_map:, dirty_map:)
+        dataset = datastore[mappings.fetch(name).namespace]
 
-    def build_dirty_map(storage = {})
-      DirtyMap.new(storage)
-    end
+        RelationalStore.new(
+          mappings: mappings,
+          mapping_name: name,
+          datastore: datastore,
+          dataset: dataset,
+          load_pipeline: build_load_pipeline(
+            dirty_map: dirty_map,
+            identity_map: identity_map,
+          ),
+          dump_pipeline: build_dump_pipeline(
+            dirty_map: dirty_map,
+            transaction: datastore.method(:transaction),
+            upsert: method(:upsert_record).curry.call(datastore),
+            delete: method(:delete_record).curry.call(datastore),
+          )
+        )
+      end
 
-    def build_load_pipeline(dirty_map:, identity_map:)
-      ->(mapping, record, associated_fields = {}) {
-        [
-          record_factory(mapping),
-          dirty_map.method(:load),
-          ->(record) {
-            attributes = record.to_h.select { |k,_v|
-              mapping.fields.include?(k)
-            }
+      def build_identity_map(storage = {})
+        IdentityMap.new(storage)
+      end
 
-            object = mapping.factory.call(attributes.merge(associated_fields))
-            identity_map.call(mapping, record, object)
-          },
-        ].reduce(record) { |agg, operation|
-          operation.call(agg)
-        }
-      }
-    end
+      def build_dirty_map(storage = {})
+        DirtyMap.new(storage)
+      end
 
-    def build_dump_pipeline(dirty_map:, transaction:, upsert:, delete:)
-      ->(records) {
-        [
-          :uniq.to_proc,
-          ->(rs) { rs.select { |r| dirty_map.dirty?(r) } },
-          ->(rs) { rs.map { |r| dirty_map.reject_unchanged_fields(r) } },
-          ->(rs) { rs.sort_by(&:depth) },
-          ->(rs) {
-            transaction.call {
-              rs.each { |r|
-                r.if_upsert(&upsert)
-                 .if_delete(&delete)
+      def build_load_pipeline(dirty_map:, identity_map:)
+        ->(mapping, record, associated_fields = {}) {
+          [
+            record_factory(mapping),
+            dirty_map.method(:load),
+            ->(record) {
+              attributes = record.to_h.select { |k,_v|
+                mapping.fields.include?(k)
               }
+
+              object = mapping.load(attributes.merge(associated_fields))
+              identity_map.call(mapping, record, object)
+            },
+          ].reduce(record) { |agg, operation|
+              operation.call(agg)
             }
-          },
-        ].reduce(records) { |agg, operation|
-          operation.call(agg)
         }
-      }
-    end
+      end
 
-    def record_factory(mapping)
-      ->(record_hash) {
-        identity = Hash[
-          mapping.primary_key.map { |field|
-            [field, record_hash.fetch(field)]
+      def build_dump_pipeline(dirty_map:, transaction:, upsert:, delete:)
+        ->(records) {
+          [
+            :uniq.to_proc,
+            ->(rs) { rs.select { |r| dirty_map.dirty?(r) } },
+            ->(rs) { rs.map { |r| dirty_map.reject_unchanged_fields(r) } },
+            ->(rs) { rs.sort_by(&:depth) },
+            ->(rs) {
+              transaction.call {
+                rs.each { |r|
+                  r.if_upsert(&upsert)
+                  .if_delete(&delete)
+                }
+              }
+            },
+            ->(rs) { rs.map { |r| dirty_map.load_if_new(r) } },
+          ].reduce(records) { |agg, operation|
+            operation.call(agg)
           }
-        ]
+        }
+      end
 
-        UpsertedRecord.new(
-          mapping.namespace,
-          identity,
-          record_hash,
-        )
-      }
-    end
+      def record_factory(mapping)
+        ->(record_hash) {
+          identity = Hash[
+            mapping.primary_key.map { |field|
+              [field, record_hash.fetch(field)]
+            }
+          ]
 
-    def upsert_record(datastore, record)
-      row_count = 0
-      unless record.non_identity_attributes.empty?
-        row_count = datastore[record.namespace].
-          where(record.identity).
-          update(record.non_identity_attributes)
+          UpsertedRecord.new(
+            mapping.namespace,
+            identity,
+            record_hash,
+          )
+        }
       end
 
-      if row_count < 1
-        row_count = datastore[record.namespace].insert(record.to_h)
+      def upsert_record(datastore, record)
+        row_count = 0
+        unless record.non_identity_attributes.empty?
+          row_count = datastore[record.namespace].
+            where(record.identity).
+            update(record.non_identity_attributes)
+        end
+
+        if row_count < 1
+          row_count = datastore[record.namespace].insert(record.to_h)
+        end
+
+        row_count
+      rescue Object => e
+        raise UpsertError.new(record.namespace, record.to_h, e)
       end
 
-      row_count
-    end
-
-    def delete_record(datastore, record)
-      datastore[record.namespace].where(record.identity).delete
+      def delete_record(datastore, record)
+        datastore[record.namespace].where(record.identity).delete
+      end
     end
   end
 end