terrestrial 0.3.0 → 0.5.0

data/lib/terrestrial/association_loaders.rb

@@ -1,52 +0,0 @@
-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/upserted_record.rb

@@ -1,15 +0,0 @@
-require "terrestrial/abstract_record"
-
-module Terrestrial
-  class UpsertedRecord < AbstractRecord
-    def if_upsert(&block)
-      block.call(self)
-      self
-    end
-
-    protected
-    def operation
-      :upsert
-    end
-  end
-end

data/spec/terrestrial/public_conveniencies_spec.rb

@@ -1,63 +0,0 @@
-require "spec_helper"
-
-require "terrestrial/public_conveniencies"
-require "ostruct"
-
-RSpec.describe Terrestrial::PublicConveniencies do
-  subject(:conveniences) {
-    Module.new.extend(Terrestrial::PublicConveniencies)
-  }
-
-  class MockDatastore < DelegateClass(Hash)
-    def transaction(&block)
-      block.call
-    end
-  end
-
-  describe "#object_store" do
-    let(:datastore) {
-      MockDatastore.new(
-        {
-          things: [ thing_record ],
-        }
-      )
-    }
-
-    let(:mappings) {
-      {
-        things: double(
-          :thing_config,
-          name: mapping_name,
-          namespace: :things,
-          fields: [:id],
-          associations: [],
-          primary_key: [],
-          load: thing_object,
-        )
-      }
-    }
-
-    let(:mapping_name) { :things }
-
-    let(:thing_record) {
-      {
-        id: "THE THING",
-      }
-    }
-
-    let(:thing_object) {
-      OpenStruct.new(thing_record)
-    }
-
-    it "returns an object store for given mappings" do
-      object_store = conveniences.object_store(
-        mappings: mappings,
-        datastore: datastore,
-      )
-
-      expect(
-        object_store[:things].all.first.id
-      ).to eq("THE THING")
-    end
-  end
-end

data/spec/terrestrial/upserted_record_spec.rb

@@ -1,59 +0,0 @@
-require "spec_helper"
-
-require "terrestrial/upserted_record"
-
-RSpec.describe Terrestrial::UpsertedRecord do
-  subject(:record) {
-    Terrestrial::UpsertedRecord.new(namespace, identity, raw_data)
-  }
-
-  let(:namespace) { double(:namespace) }
-
-  let(:identity) {
-    { id: id }
-  }
-
-  let(:raw_data) {
-    {
-      name: name,
-    }
-  }
-
-  let(:id) { double(:id) }
-  let(:name) { double(:name) }
-
-  describe "#if_upsert" do
-    it "invokes the callback" do
-      expect { |callback|
-        record.if_upsert(&callback)
-      }.to yield_with_args(record)
-    end
-  end
-
-  describe "#==" do
-    context "with another record that upserts" do
-      let(:comparitor) {
-        record.merge({})
-      }
-
-      it "is equal" do
-        expect(record.==(comparitor)).to be(true)
-      end
-    end
-
-    context "with another record that does not upsert" do
-      let(:comparitor) {
-        Class.new(Terrestrial::AbstractRecord) do
-          protected
-          def operation
-            :something_else
-          end
-        end
-      }
-
-      it "is not equal" do
-        expect(record.==(comparitor)).to be(false)
-      end
-    end
-  end
-end