terrestrial 0.1.0 → 0.1.1

data/lib/terrestrial/configurations/conventional_configuration.rb

@@ -0,0 +1,302 @@
+require "terrestrial/configurations/conventional_association_configuration"
+require "terrestrial/relation_mapping"
+require "terrestrial/subset_queries_proxy"
+require "terrestrial/struct_factory"
+
+module Terrestrial
+  module Configurations
+    require "active_support/inflector"
+    class Inflector
+      include ActiveSupport::Inflector
+    end
+
+    INFLECTOR = Inflector.new
+
+    require "fetchable"
+    class ConventionalConfiguration
+      include Fetchable
+
+      def initialize(datastore)
+        @datastore = datastore
+        @overrides = {}
+        @subset_queries = {}
+        @associations_by_mapping = {}
+      end
+
+      attr_reader :datastore, :mappings
+      private     :datastore, :mappings
+
+      def [](mapping_name)
+        mappings[mapping_name]
+      end
+
+      include Enumerable
+      def each(&block)
+        mappings.each(&block)
+      end
+
+      def setup_mapping(mapping_name, &block)
+        @associations_by_mapping[mapping_name] ||= []
+
+        block.call(
+          RelationConfigOptionsProxy.new(
+            method(:add_override).to_proc.curry.call(mapping_name),
+            method(:add_subset).to_proc.curry.call(mapping_name),
+            @associations_by_mapping.fetch(mapping_name),
+          )
+        ) if block
+
+        # TODO: more madness in this silly config this, kill it with fire.
+        explicit_settings = @overrides[mapping_name] ||= {}
+        explicit_settings[:factory] ||= raise_if_not_found_factory(mapping_name)
+
+        self
+      end
+
+      private
+
+      class RelationConfigOptionsProxy
+        def initialize(config_override, subset_adder, association_register)
+          @config_override = config_override
+          @subset_adder = subset_adder
+          @association_register = association_register
+        end
+
+        def relation_name(name)
+          @config_override.call(relation_name: name)
+        end
+        alias_method :table_name, :relation_name
+
+        def subset(subset_name, &block)
+          @subset_adder.call(subset_name, block)
+        end
+
+        def has_many(*args)
+          @association_register.push([:has_many, args])
+        end
+
+        def has_many_through(*args)
+          @association_register.push([:has_many_through, args])
+        end
+
+        def belongs_to(*args)
+          @association_register.push([:belongs_to, args])
+        end
+
+        def fields(field_names)
+          @config_override.call(fields: field_names)
+        end
+
+        def primary_key(field_names)
+          @config_override.call(primary_key: field_names)
+        end
+
+        def factory(callable)
+          @config_override.call(factory: callable)
+        end
+
+        def class(entity_class)
+          @config_override.call('class': entity_class)
+        end
+
+        def class_name(class_name)
+          @config_override.call(class_name: class_name)
+        end
+
+        def serializer(serializer_func)
+          @config_override.call(serializer: serializer_func)
+        end
+      end
+
+      def mappings
+        @mappings ||= generate_mappings
+      end
+
+      def add_override(mapping_name, attrs)
+        overrides = @overrides.fetch(mapping_name, {}).merge(attrs)
+
+        @overrides.store(mapping_name, overrides)
+      end
+
+      def add_subset(mapping_name, subset_name, block)
+        @subset_queries.store(
+          mapping_name,
+          @subset_queries.fetch(mapping_name, {}).merge(
+            subset_name => block,
+          )
+        )
+      end
+
+      def association_configurator(mappings, mapping_name)
+        ConventionalAssociationConfiguration.new(
+          mapping_name,
+          mappings,
+          datastore,
+        )
+      end
+
+      def generate_mappings
+        custom_mappings = @overrides.map { |mapping_name, overrides|
+          [mapping_name, {relation_name: mapping_name}.merge(consolidate_overrides(overrides))]
+        }
+
+        table_mappings = (tables - @overrides.keys).map { |table_name|
+          [table_name, overrides_for_table(table_name)]
+        }
+
+        Hash[
+          (table_mappings + custom_mappings).map { |(mapping_name, overrides)|
+            table_name = overrides.fetch(:relation_name) { raise no_table_error(mapping_name) }
+
+            [
+              mapping_name,
+              mapping(
+                **default_mapping_args(table_name, mapping_name).merge(overrides)
+              ),
+            ]
+          }
+        ]
+        .tap { |mappings|
+          generate_associations_config(mappings)
+        }
+      end
+
+      def generate_associations_config(mappings)
+        # TODO: the ConventionalAssociationConfiguration takes all the mappings
+        # as a dependency and then sends mutating messages to them.
+        # This mutation based approach was originally a spike but now just
+        # seems totally bananas!
+        @associations_by_mapping.each do |mapping_name, associations|
+          associations.each do |(assoc_type, assoc_args)|
+            association_configurator(mappings, mapping_name)
+              .public_send(assoc_type, *assoc_args)
+          end
+        end
+      end
+
+      def default_mapping_args(table_name, mapping_name)
+        {
+          name: mapping_name,
+          relation_name: table_name,
+          fields: get_fields(table_name),
+          primary_key: get_primary_key(table_name),
+          factory: ok_if_it_doesnt_exist_factory(mapping_name),
+          serializer: hash_coercion_serializer,
+          associations: {},
+          subsets: subset_queries_proxy(@subset_queries.fetch(mapping_name, {})),
+        }
+      end
+
+      def overrides_for_table(table_name)
+        overrides = @overrides.values.detect { |config|
+          table_name == config.fetch(:relation_name, nil)
+        } || {}
+
+        { relation_name: table_name }.merge(
+          consolidate_overrides(overrides)
+        )
+      end
+
+      def consolidate_overrides(opts)
+        new_opts = opts.dup
+
+        if new_opts.has_key?(:class_name)
+          new_opts.merge!(factory: string_to_factory(new_opts.fetch(:class_name)))
+          new_opts.delete(:class_name)
+        end
+
+        if new_opts.has_key?(:class)
+          new_opts.merge!(factory: class_to_factory(new_opts.fetch(:class)))
+          new_opts.delete(:class)
+        end
+
+        new_opts
+      end
+
+      def get_fields(table_name)
+        datastore[table_name].columns
+      end
+
+      def get_primary_key(table_name)
+        datastore.schema(table_name)
+          .select { |field_name, properties|
+            properties.fetch(:primary_key)
+          }
+          .map { |field_name, _| field_name }
+      end
+
+      def tables
+        (datastore.tables - [:schema_migrations])
+      end
+
+      def hash_coercion_serializer
+        ->(o) { o.to_h }
+      end
+
+      def subset_queries_proxy(subset_map)
+        SubsetQueriesProxy.new(subset_map)
+      end
+
+      def mapping(name:, relation_name:, primary_key:, factory:, serializer:, fields:, associations:, subsets:)
+        RelationMapping.new(
+          name: name,
+          namespace: relation_name,
+          primary_key: primary_key,
+          factory: factory,
+          serializer: serializer,
+          fields: fields,
+          associations: associations,
+          subsets: subsets,
+        )
+      end
+
+      FactoryNotFoundError = Class.new(StandardError) do
+        def initialize(specified)
+          @specified = specified
+        end
+
+        def message
+          "Could not find factory for #{@specified}"
+        end
+      end
+
+      TableNameNotSpecifiedError = Class.new(StandardError) do
+        def initialize(mapping_name)
+          @message = "Error defining custom mapping `#{mapping_name}`." +
+            " You must provide the `table_name` configuration option."
+        end
+      end
+
+      def raise_if_not_found_factory(name)
+        ->(attrs) {
+          class_to_factory(string_to_class(name)).call(attrs)
+        }
+      end
+
+      def ok_if_it_doesnt_exist_factory(name)
+        ->(attrs) {
+          factory = class_to_factory(string_to_class(name)) rescue nil
+          factory && factory.call(attrs)
+        }
+      end
+
+      def class_to_factory(klass)
+        if klass.ancestors.include?(Struct)
+          StructFactory.new(klass)
+        else
+          klass.method(:new)
+        end
+      end
+
+      def string_to_class(string)
+        klass_name = INFLECTOR.classify(string)
+
+        Object.const_get(klass_name)
+      end
+
+      def no_table_error(table_name)
+        TableNameNotSpecifiedError.new(table_name)
+      end
+    end
+  end
+end

data/lib/terrestrial/dataset.rb

@@ -0,0 +1,49 @@
+module Terrestrial
+  class Dataset
+    include Enumerable
+
+    def initialize(records)
+      @records = records
+    end
+
+    attr_reader :records
+    private     :records
+
+    def each(&block)
+      records.each(&block)
+      self
+    end
+
+    def where(criteria)
+      new(
+        records.find_all { |row|
+          criteria.all? { |k, v|
+            if v.respond_to?(:include?)
+              test_inclusion_in_value(row, k, v)
+            else
+              test_equality(row, k, v)
+            end
+          }
+        }
+      )
+    end
+
+    def select(field)
+      map { |data| data.fetch(field) }
+    end
+
+    private
+
+    def new(records)
+      self.class.new(records)
+    end
+
+    def test_inclusion_in_value(row, field, values)
+      values.include?(row.fetch(field))
+    end
+
+    def test_equality(row, field, value)
+      value == row.fetch(field)
+    end
+  end
+end

data/lib/terrestrial/deleted_record.rb

@@ -0,0 +1,20 @@
+require "terrestrial/abstract_record"
+
+module Terrestrial
+  class DeletedRecord < AbstractRecord
+    def if_delete(&block)
+      block.call(self)
+      self
+    end
+
+    def subset?(_other)
+      false
+    end
+
+    protected
+
+    def operation
+      :delete
+    end
+  end
+end

data/lib/terrestrial/dirty_map.rb

@@ -0,0 +1,42 @@
+module Terrestrial
+  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), NotFound)
+      return true if record_as_loaded == NotFound
+
+      !record.subset?(record_as_loaded)
+    end
+
+    def reject_unchanged_fields(record)
+      record_as_loaded = storage.fetch(hash_key(record), {})
+
+      record.reject { |field, value|
+        value == record_as_loaded.fetch(field, NotFound)
+      }
+    end
+
+    private
+
+    NotFound = Module.new
+
+    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/terrestrial/graph_loader.rb

@@ -0,0 +1,63 @@
+module Terrestrial
+  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|
+        assoc_eager_data = eager_data.fetch(name, {})
+
+        data_superset = assoc_eager_data.fetch(:superset) {
+          load_from_datasets(association)
+        }
+
+        [
+          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,
+                assoc_eager_data.fetch(:associations, {})
+              )
+            },
+          )
+        ]
+      }
+    end
+
+    def load_from_datasets(association)
+      association
+      .mapping_names
+      .map { |name| mappings.fetch(name) }
+      .map(&:namespace)
+      .map { |ns| datasets[ns] }
+    end
+  end
+end

data/lib/terrestrial/graph_serializer.rb

@@ -0,0 +1,91 @@
+require "terrestrial/upserted_record"
+require "terrestrial/deleted_record"
+
+module Terrestrial
+  class GraphSerializer
+    def initialize(mappings:)
+      @mappings = mappings
+      @serialization_map = {}
+    end
+
+    attr_reader :mappings, :serialization_map
+    private     :mappings, :serialization_map
+
+    def call(mapping_name, object, depth = 0, parent_foreign_keys = {})
+      if serialization_map.include?(object)
+        return [serialization_map.fetch(object)]
+      end
+
+      mapping = mappings.fetch(mapping_name)
+
+      current_record, association_fields = mapping.serialize(
+        object,
+        depth,
+        parent_foreign_keys,
+      )
+
+      serialization_map.store(object, current_record)
+
+      (
+        [current_record] + associated_records(mapping, current_record, association_fields, depth)
+      ).flatten(1)
+    end
+
+    private
+
+    def associated_records(mapping, current_record, association_fields, depth)
+      mapping.associations
+        .map { |name, association|
+          [association_fields.fetch(name), association]
+        }
+        .map { |collection, association|
+          [nodes(collection), deleted_nodes(collection), association]
+        }
+        .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 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,
+        )
+      ]
+    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
+  end
+end

data/lib/terrestrial/identity_map.rb

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

data/lib/terrestrial/lazy_collection.rb

@@ -0,0 +1,74 @@
+require "terrestrial/short_inspection_string"
+
+module Terrestrial
+  class LazyCollection
+    include ShortInspectionString
+    include Enumerable
+
+    def initialize(database_enum, loader, queries)
+      @database_enum = database_enum
+      @loader = loader
+      @queries = queries
+      @loaded = false
+    end
+
+    attr_reader :database_enum, :loader, :queries
+    private     :database_enum, :loader, :queries
+
+    def where(criteria)
+      self.class.new(database_enum.where(criteria), loader, queries)
+    end
+
+    def subset(name, *params)
+      self.class.new(
+        queries.execute(database_enum, name, *params),
+        loader,
+        queries,
+      )
+    end
+
+    def to_ary
+      to_a
+    end
+
+    def each(&block)
+      enum.each(&block)
+    end
+
+    def each_loaded(&block)
+      loaded_objects.each(&block)
+    end
+
+    private
+
+    def enum
+      @enum ||= Enumerator.new { |yielder|
+        loaded_objects.each do |obj|
+          yielder.yield(obj)
+        end
+
+        loop do
+          object_enum.next.tap { |obj|
+            loaded_objects.push(obj)
+            yielder.yield(obj)
+          }
+        end
+      }
+    end
+
+    def object_enum
+      @object_enum ||= database_enum.lazy.map(&loader)
+    end
+
+    def loaded_objects
+      @loaded_objects ||= []
+    end
+
+    def inspectable_properties
+      [
+        :database_enum,
+        :loaded,
+      ]
+    end
+  end
+end