terrestrial 0.1.0 → 0.1.1

data/features/step_definitions/example_steps.rb

@@ -0,0 +1,46 @@
+Given(/^the domain objects are defined$/) do |code_sample|
+  Object.module_eval(code_sample)
+end
+
+Given(/^a database connection is established$/) do |code_sample|
+  example_eval(code_sample)
+end
+
+Given(/^the associations are defined in the mapper configuration$/) do |code_sample|
+  example_eval(code_sample)
+end
+
+Given(/^a mapper is instantiated$/) do |code_sample|
+  example_eval(code_sample)
+end
+
+Given(/^a conventionally similar database schema for table "(.*?)"$/) do |table_name, schema_table|
+  create_table(table_name, parse_schema_table(schema_table))
+end
+
+When(/^a new graph of objects are created$/) do |code_sample|
+  @objects_to_be_saved_sample = code_sample
+end
+
+When(/^the new graph is saved$/) do |save_objects_code|
+  example_eval(
+    [@objects_to_be_saved_sample, save_objects_code].join("\n")
+  )
+end
+
+When(/^the following query is executed$/) do |code_sample|
+  @query = code_sample
+  @result = example_eval(code_sample)
+end
+
+Then(/^the persisted user object is returned with lazy associations$/) do |expected_inspection_string|
+  expect(normalise_inspection_string(@result.inspect))
+    .to eq(normalise_inspection_string(expected_inspection_string))
+end
+
+Then(/^the user's posts will be loaded once the association proxy receives an Enumerable message$/) do |expected_inspection_string|
+  posts = @result.posts.to_a
+
+  expect(normalise_inspection_string(posts.inspect))
+    .to eq(normalise_inspection_string(expected_inspection_string))
+end

data/lib/terrestrial/abstract_record.rb

@@ -0,0 +1,99 @@
+require "forwardable"
+require "set"
+
+module Terrestrial
+  class AbstractRecord
+    extend Forwardable
+    include Comparable
+    include Enumerable
+
+    def initialize(namespace, identity_fields, attributes = {}, depth = NoDepth)
+      @namespace = namespace
+      @identity_fields = identity_fields
+      @attributes = attributes
+      @depth = depth
+    end
+
+    attr_reader :namespace, :identity_fields, :attributes, :depth
+    private :attributes
+
+    def_delegators :to_h, :fetch
+
+    def if_upsert(&block)
+      self
+    end
+
+    def if_delete(&block)
+      self
+    end
+
+    def each(&block)
+      to_h.each(&block)
+    end
+
+    def keys
+      attributes.keys
+    end
+
+    def identity
+      attributes.select { |k,_v| identity_fields.include?(k) }
+    end
+
+    def non_identity_attributes
+      attributes.reject { |k| identity.include?(k) }
+    end
+
+    def merge(more_data)
+      new_with_raw_data(attributes.merge(more_data))
+    end
+
+    def merge!(more_data)
+      attributes.merge!(more_data)
+    end
+
+    def reject(&block)
+      new_with_raw_data(non_identity_attributes.reject(&block).merge(identity))
+    end
+
+    def to_h
+      attributes.to_h
+    end
+
+    def empty?
+      non_identity_attributes.empty?
+    end
+
+    def ==(other)
+      self.class === other &&
+        [operation, to_h] == [other.operation, other.to_h]
+    end
+
+    def <=>(other)
+      depth <=> other.depth
+    end
+
+    def subset?(other_record)
+      namespace == other_record.namespace &&
+        to_set.subset?(other_record.to_set)
+    end
+
+    protected
+
+    def operation
+      NoOp
+    end
+
+    def to_set
+      Set.new(attributes.to_a)
+    end
+
+    private
+
+    NoOp = Module.new
+    NoDepth = Module.new
+
+    def new_with_raw_data(new_raw_data)
+      self.class.new(namespace, identity_fields, new_raw_data, depth)
+    end
+  end
+end

data/lib/terrestrial/association_loaders.rb

@@ -0,0 +1,52 @@
+module Terrestrial
+  module AssociationLoaders
+    class OneToMany
+      def initialize(type:, mapping_name:, foreign_key:, key:, proxy_factory:)
+        @type = type
+        @mapping_name = mapping_name
+        @foreign_key = foreign_key
+        @key = key
+        @proxy_factory = proxy_factory
+        @eager_loads = {}
+      end
+
+      attr_reader :type, :mapping_name, :foreign_key, :key, :proxy_factory
+      private     :type, :mapping_name, :foreign_key, :key, :proxy_factory
+
+      def fetch(*args, &block)
+        {
+          key: key,
+          foreign_key: foreign_key,
+          type: type,
+          mapping_name: mapping_name,
+        }.fetch(*args, &block)
+      end
+
+      def call(mappings, record, &object_pipeline)
+        mapping = mappings.fetch(mapping_name)
+
+        proxy_factory.call(
+          query: query(mapping, record),
+          loader: object_pipeline.call(mapping),
+          association_loader: self,
+        )
+      end
+
+      def query(mapping, record)
+        foreign_key_value = record.fetch(key)
+
+        ->(datastore) {
+          @eager_loads.fetch(record) {
+            datastore[mapping.namespace]
+              .where(foreign_key => foreign_key_value)
+          }
+        }
+      end
+
+      def eager_load(dataset, association_name)
+        datastore[mapping.namespace]
+          .where(foreign_key => dataset.select(key))
+      end
+    end
+  end
+end

data/lib/terrestrial/collection_mutability_proxy.rb

@@ -0,0 +1,81 @@
+require "forwardable"
+require "terrestrial/short_inspection_string"
+
+module Terrestrial
+  class CollectionMutabilityProxy
+    extend Forwardable
+    include ShortInspectionString
+    include Enumerable
+
+    def initialize(collection)
+      @collection = collection
+      @added_nodes = []
+      @deleted_nodes = []
+    end
+
+    attr_reader :collection, :deleted_nodes, :added_nodes
+    private     :collection, :deleted_nodes, :added_nodes
+
+    def_delegators :collection, :where, :subset
+
+    def each_loaded(&block)
+      loaded_enum.each(&block)
+    end
+
+    def each_deleted(&block)
+      @deleted_nodes.each(&block)
+    end
+
+    def to_ary
+      to_a
+    end
+
+    def each(&block)
+      if block
+        enum.each(&block)
+        self
+      else
+        enum
+      end
+    end
+
+    def delete(node)
+      @deleted_nodes.push(node)
+      self
+    end
+
+    def push(node)
+      @added_nodes.push(node)
+    end
+
+    private
+
+    def loaded_enum
+      Enumerator.new do |yielder|
+        collection.each_loaded do |element|
+          yielder.yield(element) unless deleted?(element)
+        end
+
+        added_nodes.each do |node|
+          yielder.yield(node)
+        end
+      end
+    end
+
+    def enum
+      Enumerator.new do |yielder|
+        collection.each do |element|
+          yielder.yield(element) unless deleted?(element)
+        end
+
+        added_nodes.each do |node|
+          yielder.yield(node)
+        end
+      end
+    end
+
+    def deleted?(node)
+      @deleted_nodes.include?(node)
+    end
+  end
+end

data/lib/terrestrial/configurations/conventional_association_configuration.rb

@@ -0,0 +1,186 @@
+require "terrestrial/query_order"
+
+module Terrestrial
+  module Configurations
+    require "terrestrial/one_to_many_association"
+    require "terrestrial/many_to_many_association"
+    require "terrestrial/many_to_one_association"
+    require "terrestrial/collection_mutability_proxy"
+    require "terrestrial/lazy_collection"
+    require "terrestrial/lazy_object_proxy"
+
+    class ConventionalAssociationConfiguration
+      def initialize(mapping_name, mappings, datastore)
+        @local_mapping_name = mapping_name
+        @mappings = mappings
+        @local_mapping = mappings.fetch(local_mapping_name)
+        @datastore = datastore
+      end
+
+      attr_reader :local_mapping_name, :local_mapping, :mappings, :datastore
+      private     :local_mapping_name, :local_mapping, :mappings, :datastore
+
+      DEFAULT = Module.new
+
+      def has_many(association_name, key: DEFAULT, foreign_key: DEFAULT, mapping_name: DEFAULT, order_fields: DEFAULT, order_direction: DEFAULT)
+        defaults = {
+          mapping_name: association_name,
+          foreign_key: [INFLECTOR.singularize(local_mapping_name), "_id"].join.to_sym,
+          key: :id,
+          order_fields: [],
+          order_direction: "ASC",
+        }
+
+        specified = {
+          mapping_name: mapping_name,
+          foreign_key: foreign_key,
+          key: key,
+          order_fields: order_fields,
+          order_direction: order_direction,
+        }.reject { |_k,v|
+          v == DEFAULT
+        }
+
+        config = defaults.merge(specified)
+        associated_mapping_name = config.fetch(:mapping_name)
+        associated_mapping = mappings.fetch(associated_mapping_name)
+
+        local_mapping.add_association(
+          association_name,
+          has_many_mapper(**config)
+        )
+      end
+
+      def belongs_to(association_name, key: DEFAULT, foreign_key: DEFAULT, mapping_name: DEFAULT)
+        defaults = {
+          key: :id,
+          foreign_key: [association_name, "_id"].join.to_sym,
+          mapping_name: INFLECTOR.pluralize(association_name).to_sym,
+        }
+
+        specified = {
+          mapping_name: mapping_name,
+          foreign_key: foreign_key,
+          key: key,
+        }.reject { |_k,v|
+          v == DEFAULT
+        }
+
+        config = defaults.merge(specified)
+
+        associated_mapping_name = config.fetch(:mapping_name)
+        associated_mapping = mappings.fetch(associated_mapping_name)
+
+        local_mapping.add_association(
+          association_name,
+          belongs_to_mapper(**config)
+        )
+      end
+
+      def has_many_through(association_name, key: DEFAULT, foreign_key: DEFAULT, mapping_name: DEFAULT, through_mapping_name: DEFAULT, association_key: DEFAULT, association_foreign_key: DEFAULT, order_fields: DEFAULT, order_direction: DEFAULT)
+        defaults = {
+          mapping_name: association_name,
+          key: :id,
+          association_key: :id,
+          foreign_key: [INFLECTOR.singularize(local_mapping_name), "_id"].join.to_sym,
+          association_foreign_key: [INFLECTOR.singularize(association_name), "_id"].join.to_sym,
+          order_fields: [],
+          order_direction: "ASC",
+        }
+
+        specified = {
+          mapping_name: mapping_name,
+          key: key,
+          association_key: association_key,
+          foreign_key: foreign_key,
+          association_foreign_key: association_foreign_key,
+          order_fields: order_fields,
+          order_direction: order_direction,
+        }.reject { |_k,v|
+          v == DEFAULT
+        }
+
+        config = defaults.merge(specified)
+        associated_mapping = mappings.fetch(config.fetch(:mapping_name))
+
+        if through_mapping_name == DEFAULT
+          through_mapping_name = [
+            associated_mapping.name,
+            local_mapping.name,
+          ].sort.join("_to_").to_sym
+        end
+
+        join_table_name = mappings.fetch(through_mapping_name).namespace
+        config = config
+          .merge(
+            through_mapping_name: through_mapping_name,
+            through_dataset: datastore[join_table_name.to_sym],
+          )
+
+        local_mapping.add_association(
+          association_name,
+          has_many_through_mapper(**config)
+        )
+      end
+
+      private
+
+      def has_many_mapper(mapping_name:, key:, foreign_key:, order_fields:, order_direction:)
+        OneToManyAssociation.new(
+          mapping_name: mapping_name,
+          foreign_key: foreign_key,
+          key: key,
+          order: query_order(order_fields, order_direction),
+          proxy_factory: collection_proxy_factory,
+        )
+      end
+
+      def belongs_to_mapper(mapping_name:, key:, foreign_key:)
+        ManyToOneAssociation.new(
+          mapping_name: mapping_name,
+          foreign_key: foreign_key,
+          key: key,
+          proxy_factory: single_object_proxy_factory,
+        )
+      end
+
+      def has_many_through_mapper(mapping_name:, key:, foreign_key:, association_key:, association_foreign_key:, through_mapping_name:, through_dataset:, order_fields:, order_direction:)
+        ManyToManyAssociation.new(
+          mapping_name: mapping_name,
+          join_mapping_name: through_mapping_name,
+          key: key,
+          foreign_key: foreign_key,
+          association_key: association_key,
+          association_foreign_key: association_foreign_key,
+          proxy_factory: collection_proxy_factory,
+          order: query_order(order_fields, order_direction),
+        )
+      end
+
+      def single_object_proxy_factory
+        ->(query:, loader:, preloaded_data:) {
+          LazyObjectProxy.new(
+            ->{ loader.call(query.first) },
+            preloaded_data,
+          )
+        }
+      end
+
+      def collection_proxy_factory
+        ->(query:, loader:, mapping_name:) {
+          CollectionMutabilityProxy.new(
+            LazyCollection.new(
+              query,
+              loader,
+              mappings.fetch(mapping_name).subsets,
+            )
+          )
+        }
+      end
+
+      def query_order(fields, direction)
+        QueryOrder.new(fields: fields, direction: direction)
+      end
+    end
+  end
+end