sequel_mapper 0.0.1 → 0.0.3

data/lib/sequel_mapper/dataset.rb

@@ -0,0 +1,37 @@
+module SequelMapper
+  class Dataset
+    def initialize(records)
+      @records = records
+    end
+
+    attr_reader :records
+    private     :records
+
+    include Enumerable
+
+    def each(&block)
+      records.each(&block)
+      self
+    end
+
+    def where(criteria)
+      new(
+        records.select { |row|
+          criteria.all? { |k, v|
+            row.fetch(k, :nope) == v
+          }
+        }
+      )
+    end
+
+    def select(field)
+      map { |data| data.fetch(field) }
+    end
+
+    private
+
+    def new(records)
+      self.class.new(records)
+    end
+  end
+end

data/lib/sequel_mapper/deleted_record.rb

@@ -0,0 +1,16 @@
+require "sequel_mapper/abstract_record"
+
+module SequelMapper
+  class DeletedRecord < AbstractRecord
+    def if_delete(&block)
+      block.call(self)
+      self
+    end
+
+    protected
+
+    def operation
+      :delete
+    end
+  end
+end

data/lib/sequel_mapper/dirty_map.rb

@@ -0,0 +1,31 @@
+module SequelMapper
+  class DirtyMap
+    def initialize(storage)
+      @storage = storage
+    end
+
+    attr_reader :storage
+    private     :storage
+
+    def load(record)
+      storage.store(hash_key(record), deep_clone(record))
+      record
+    end
+
+    def dirty?(record)
+      record_as_loaded = storage.fetch(hash_key(record), :not_found)
+
+      record != record_as_loaded
+    end
+
+    private
+
+    def hash_key(record)
+      deep_clone([record.namespace, record.identity])
+    end
+
+    def deep_clone(record)
+      Marshal.load(Marshal.dump(record))
+    end
+  end
+end

data/lib/sequel_mapper/graph_loader.rb

@@ -0,0 +1,48 @@
+module SequelMapper
+  class GraphLoader
+    def initialize(datasets:, mappings:, object_load_pipeline:)
+      @datasets = datasets
+      @mappings = mappings
+      @object_load_pipeline = object_load_pipeline
+    end
+
+    attr_reader :datasets, :mappings, :object_load_pipeline
+
+    def call(mapping_name, record, eager_data = {})
+      mapping = mappings.fetch(mapping_name)
+
+      load_record(mapping, record, eager_data)
+    end
+
+    private
+
+    def load_record(mapping, record, eager_data)
+      associations = load_associations(mapping, record, eager_data)
+
+      object_load_pipeline.call(mapping, record, Hash[associations])
+    end
+
+    def load_associations(mapping, record, eager_data)
+      mapping.associations.map { |name, association|
+        data_superset = eager_data.fetch([mapping.name, name]) {
+          datasets[mappings.fetch(association.mapping_name).namespace]
+        }
+
+        [
+          name,
+          association.build_proxy(
+            record: record,
+            data_superset: data_superset,
+            loader: ->(associated_record, join_records = []) {
+              join_records.map { |jr|
+                join_mapping = mappings.fetch(association.join_mapping_name)
+                object_load_pipeline.call(join_mapping, jr)
+              }
+              call(association.mapping_name, associated_record, eager_data)
+            },
+          )
+        ]
+      }
+    end
+  end
+end

data/lib/sequel_mapper/graph_serializer.rb

@@ -0,0 +1,107 @@
+require "sequel_mapper/upserted_record"
+require "sequel_mapper/deleted_record"
+
+module SequelMapper
+  class GraphSerializer
+    def initialize(mappings:)
+      @mappings = mappings
+      @count = 0
+      @encountered_records = Set.new
+    end
+
+    attr_reader :mappings, :encountered_records
+    private     :mappings, :encountered_records
+
+    def call(mapping_name, object, foreign_key = {})
+      # TODO may need some attention :)
+      mapping = mappings.fetch(mapping_name)
+      serializer = mapping.serializer
+      namespace = mapping.namespace
+      primary_key = mapping.primary_key
+      fields = mapping.fields
+      associations_map = mapping.associations
+
+      serialized_record = serializer.call(object)
+
+      current_record = UpsertedRecord.new(
+        namespace,
+        record_identity(primary_key, serialized_record),
+        serialized_record
+          .select { |k, _v| fields.include?(k) }
+          .merge(foreign_key)
+      )
+
+      if encountered_records.include?(current_record.identity)
+        return [current_record]
+      else
+        encountered_records.add(current_record.identity)
+      end
+
+      [current_record] + associations_map
+        .map { |name, association|
+          [serialized_record.fetch(name), association]
+        }
+        .map { |collection, association|
+          [nodes(collection), deleted_nodes(collection), association]
+        }
+        .map { |nodes, deleted_nodes, association|
+          assoc_mapping = mappings.fetch(association.mapping_name)
+
+          association.dump(current_record, nodes) { |assoc_mapping_name, assoc_object, foreign_key|
+            call(assoc_mapping_name, assoc_object, foreign_key)
+          } +
+          association.delete(current_record, deleted_nodes) { |assoc_mapping_name, assoc_object, foreign_key|
+            delete(assoc_mapping_name, assoc_object, foreign_key)
+          }
+        }
+        .flatten(1)
+    end
+
+    private
+
+    def delete(mapping_name, object, _foreign_key)
+      # TODO copypasta ¯\_(ツ)_/¯
+      mapping = mappings.fetch(mapping_name)
+      primary_key = mapping.primary_key
+      serializer = mapping.serializer
+      namespace = mapping.namespace
+
+      serialized_record = serializer.call(object)
+
+      [
+        DeletedRecord.new(
+          namespace,
+          record_identity(primary_key, serialized_record),
+        )
+      ]
+    end
+
+    def nodes(collection)
+      if collection.respond_to?(:each_loaded)
+        collection.each_loaded
+      elsif collection.is_a?(Struct)
+        [collection]
+      elsif collection.respond_to?(:each)
+        collection.each
+      else
+        collection
+      end
+    end
+
+    def deleted_nodes(collection)
+      if collection.respond_to?(:each_deleted)
+        collection.each_deleted
+      else
+        []
+      end
+    end
+
+    def record_identity(primary_key, record)
+      Hash[
+        primary_key.map { |field|
+          [field, record.fetch(field)]
+        }
+      ]
+    end
+  end
+end

data/lib/sequel_mapper/identity_map.rb

@@ -0,0 +1,22 @@
+module SequelMapper
+  class IdentityMap
+    def initialize(storage)
+      @storage = storage
+    end
+
+    attr_reader :storage
+    private     :storage
+
+    def call(record, object)
+      storage.fetch(hash_key(record)) {
+        storage.store(hash_key(record), object)
+      }
+    end
+
+    private
+
+    def hash_key(record)
+      [record.namespace, record.identity]
+    end
+  end
+end

data/lib/sequel_mapper/lazy_object_proxy.rb

@@ -0,0 +1,51 @@
+module SequelMapper
+  class LazyObjectProxy
+    include ShortInspectionString
+
+    def initialize(object_loader, known_fields)
+      @object_loader = object_loader
+      @known_fields = known_fields
+      @lazy_object = nil
+    end
+
+    attr_reader :object_loader, :known_fields
+    private     :object_loader, :known_fields
+
+    def method_missing(method_id, *args, &block)
+      if args.empty? && known_fields.include?(method_id)
+        known_fields.fetch(method_id)
+      else
+        lazy_object.public_send(method_id, *args, &block)
+      end
+    end
+
+    def loaded?
+      !!@lazy_object
+    end
+
+    def __getobj__
+      lazy_object
+    end
+
+    def each_loaded(&block)
+      [self].select(&:loaded?).each(&block)
+    end
+
+    private
+
+    def respond_to_missing?(method_id, _include_private = false)
+      known_fields.include?(method_id) || lazy_object.respond_to?(method_id)
+    end
+
+    def lazy_object
+      @lazy_object ||= object_loader.call
+    end
+
+    def inspectable_properties
+      [
+        :known_fields,
+        :lazy_object,
+      ]
+    end
+  end
+end

data/lib/sequel_mapper/many_to_many_association.rb

@@ -0,0 +1,181 @@
+require "sequel_mapper/dataset"
+
+module SequelMapper
+  class ManyToManyAssociation
+    def initialize(mapping_name:, foreign_key:, key:, proxy_factory:, association_foreign_key:, association_key:, join_mapping_name:, join_dataset:, order:)
+      @mapping_name = mapping_name
+      @foreign_key = foreign_key
+      @key = key
+      @proxy_factory = proxy_factory
+      @association_foreign_key = association_foreign_key
+      @association_key = association_key
+      @join_mapping_name = join_mapping_name
+      @join_dataset = join_dataset
+      @order = order
+    end
+
+    attr_reader :mapping_name, :join_mapping_name
+
+    attr_reader :foreign_key, :key, :proxy_factory, :association_key, :association_foreign_key, :join_dataset, :order
+    private     :foreign_key, :key, :proxy_factory, :association_key, :association_foreign_key, :join_dataset, :order
+
+    def build_proxy(data_superset:, loader:, record:)
+     proxy_factory.call(
+        query: build_query(data_superset, record),
+        loader: ->(record_list) {
+          record = record_list.first
+          join_records = record_list.last
+
+          loader.call(record, join_records)
+        },
+        mapping_name: mapping_name,
+      )
+    end
+
+    def eager_superset(superset, associated_dataset)
+      # TODO: All these keys can be confusing, write some focused tests.
+      eager_join_dataset = Dataset.new(
+        join_dataset
+          .where(foreign_key => associated_dataset.select(association_key))
+          .to_a
+      )
+
+      eager_dataset = superset
+        .where(key => eager_join_dataset.select(association_foreign_key))
+        .to_a
+
+      JoinedDataset.new(eager_dataset, eager_join_dataset)
+    end
+
+    def build_query(superset, parent_record)
+      order
+        .apply(
+          superset.join(join_mapping_name, association_foreign_key => key)
+            .where(foreign_key => foreign_key_value(parent_record))
+        )
+        .lazy.map { |record|
+          [record, [foreign_keys(parent_record, record)]]
+        }
+    end
+
+    class JoinedDataset < Dataset
+      def initialize(records, join_records)
+        @records = records
+        @join_records = join_records
+      end
+
+      def join(_relation_name, _conditions)
+        # TODO: This works for the current test suite but is probably too
+        # simplistic. Perhaps if the dataset was aware of its join conditions
+        # it would be able to intellegently skip joining or delegate
+        self
+      end
+
+      def where(criteria)
+        self.class.new(
+          *decompose_set(
+            find_like_sequel(criteria)
+          )
+        )
+      end
+
+      private
+
+      def decompose_set(set)
+        set.map(&:to_pair).transpose.+([ [], [] ]).take(2)
+      end
+
+      def find_like_sequel(criteria)
+        joined_records
+          .select { |record|
+            criteria.all? { |k, v|
+              record.fetch(k, :nope) == v
+            }
+          }
+      end
+
+      def joined_records
+        # TODO: there will inevitably nearly always be a mismatch between the
+        # number of records and unique join records. This zip/transpose
+        # approach may be too simplistic.
+        @joined_records ||= records
+          .zip(@join_records)
+          .map { |record, join_record|
+            JoinedRecord.new(record, join_record)
+          }
+      end
+
+      class JoinedRecord
+        def initialize(record, join_record)
+          @record = record
+          @join_record = join_record
+        end
+
+        attr_reader :record, :join_record
+        private      :record, :join_record
+
+        def to_pair
+          [record, join_record]
+        end
+
+        def to_h
+          @record
+        end
+
+        def fetch(key, default = NO_DEFAULT, &block)
+          args = [key, default].reject { |a| a == NO_DEFAULT }
+
+          @record.fetch(key) {
+            @join_record.fetch(*args, &block)
+          }
+        end
+
+        NO_DEFAULT = Module.new
+      end
+    end
+
+    def dump(parent_record, collection, &block)
+      flat_list_of_records_and_join_records(parent_record, collection, &block)
+    end
+
+    def delete(parent_record, collection, &block)
+      flat_list_of_just_join_records(parent_record, collection, &block)
+    end
+
+    private
+
+    def flat_list_of_records_and_join_records(parent_record, collection, &block)
+      record_join_record_pairs(parent_record, collection, &block).flatten(1)
+    end
+
+    def flat_list_of_just_join_records(parent_record, collection, &block)
+      record_join_record_pairs(parent_record, collection, &block)
+        .map { |(_records, join_records)| join_records }
+        .flatten(1)
+    end
+
+    def record_join_record_pairs(parent_record, collection, &block)
+      (collection || []).map { |associated_object|
+        records = block.call(mapping_name, associated_object, _no_foreign_key = {})
+
+        join_records = records.take(1).flat_map { |record|
+          fks = foreign_keys(parent_record, record)
+          block.call(join_mapping_name, fks, fks)
+        }
+
+        records + join_records
+      }
+    end
+
+    def foreign_keys(parent_record, record)
+      {
+        foreign_key => foreign_key_value(parent_record),
+        association_foreign_key => record.fetch(association_key),
+      }
+    end
+
+    def foreign_key_value(record)
+      record.fetch(key)
+    end
+  end
+end