terrestrial 0.1.0 → 0.1.1

data/lib/terrestrial/short_inspection_string.rb

@@ -0,0 +1,18 @@
+module Terrestrial
+  module ShortInspectionString
+    def inspect
+      "\#<#{self.class.name}:#{self.object_id.<<(1).to_s(16)} " +
+        inspectable_properties.map { |property|
+          [
+            property,
+            instance_variable_get("@#{property}").inspect
+          ].join("=")
+        }
+        .join(" ") + ">"
+    end
+
+    def inspectable_properties
+      []
+    end
+  end
+end

data/lib/terrestrial/struct_factory.rb

@@ -0,0 +1,17 @@
+module Terrestrial
+  class StructFactory
+    def initialize(struct_class)
+      @constructor = struct_class.method(:new)
+      @members = struct_class.members
+    end
+
+    attr_reader :constructor, :members
+    private     :constructor, :members
+
+    def call(data)
+      constructor.call(
+        *members.map { |m| data.fetch(m, nil) }
+      )
+    end
+  end
+end

data/lib/terrestrial/subset_queries_proxy.rb

@@ -0,0 +1,11 @@
+module Terrestrial
+  class SubsetQueriesProxy
+    def initialize(query_map)
+      @query_map = query_map
+    end
+
+    def execute(superset, name, *params)
+      @query_map.fetch(name).call(superset, *params)
+    end
+  end
+end

data/lib/terrestrial/upserted_record.rb

@@ -0,0 +1,15 @@
+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/lib/terrestrial/version.rb

@@ -1,3 +1,3 @@
 module Terrestrial
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/terrestrial.rb

@@ -1,5 +1,8 @@
-require "terrestrial/version"
+require "logger"
+require "terrestrial/public_conveniencies"
 
 module Terrestrial
-  # Your code goes here...
+  extend PublicConveniencies
+
+  LOGGER = Logger.new(STDERR)
 end

data/sequel_mapper.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'terrestrial/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "terrestrial"
+  spec.version       = Terrestrial::VERSION
+  spec.authors       = ["Stephen Best"]
+  spec.email         = ["bestie@gmail.com"]
+  spec.summary       = %q{A data mapping ORM to make your objects feel less alien}
+  spec.description   = %q{Terrestial persists your POROs while keeping them free of database concerns.}
+  spec.homepage      = "https://github.com/bestie/terrestrial"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry", "~> 0.10.1"
+  spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "pg", "~> 0.17.1"
+
+  spec.add_dependency "sequel", "~> 4.16"
+  spec.add_dependency "activesupport", "~> 4.0"
+  spec.add_dependency "fetchable", "~> 1.0"
+end

data/spec/config_override_spec.rb

@@ -0,0 +1,193 @@
+require "spec_helper"
+require "ostruct"
+
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "terrestrial"
+
+require "terrestrial/configurations/conventional_configuration"
+
+RSpec.describe "Configuration override" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  let(:mappers) {
+    Terrestrial.mappers(mappings: override_config, datastore: datastore)
+  }
+
+  let(:override_config) {
+    Terrestrial::Configurations::ConventionalConfiguration.new(datastore)
+      .setup_mapping(:users) { |users|
+        users.has_many :posts, foreign_key: :author_id
+        users.fields([:id, :first_name, :last_name, :email])
+      }
+  }
+
+  let(:user) {
+    user_mapper.where(id: "users/1").first
+  }
+
+  context "override the root mapper factory" do
+    context "with a Struct class" do
+      before do
+        override_config.setup_mapping(:users) do |config|
+          config.class(user_struct)
+        end
+      end
+
+      let(:user_struct) { Struct.new(*User.members) }
+
+      it "uses the class from the override" do
+        expect(user.class).to be(user_struct)
+      end
+    end
+  end
+
+  context "override an association" do
+    context "with a callable factory" do
+      before do
+        override_config.setup_mapping(:posts) do |config|
+          config.factory(override_post_factory)
+          config.fields([:id, :subject, :body, :created_at])
+        end
+      end
+
+      let(:post_class) { Class.new(OpenStruct) }
+
+      let(:override_post_factory) {
+        post_class.method(:new)
+      }
+
+      let(:posts) {
+        user.posts
+      }
+
+      it "uses the specified factory" do
+        expect(posts.first.class).to be(post_class)
+      end
+    end
+  end
+
+  context "override table names" do
+    context "for just the top level mapping" do
+      before do
+        datastore.rename_table(:users, unconventional_table_name)
+      end
+
+      after do
+        datastore.rename_table(unconventional_table_name, :users)
+      end
+
+      let(:override_config) {
+        Terrestrial::Configurations::ConventionalConfiguration
+        .new(datastore)
+        .setup_mapping(:users) do |config|
+          config.relation_name unconventional_table_name
+          config.class(OpenStruct)
+        end
+      }
+
+      let(:datastore) { db_connection }
+
+      let(:unconventional_table_name) {
+        :users_is_called_this_weird_thing_perhaps_for_legacy_reasons
+      }
+
+      it "maps data from the specified relation" do
+        expect(
+          user_mapper.map(&:id)
+        ).to eq(["users/1", "users/2", "users/3"])
+      end
+    end
+
+    context "for associated collections" do
+      before do
+        rename_all_the_tables
+        setup_the_strange_table_name_mappings
+      end
+
+      after do
+        undo_rename_all_the_tables
+      end
+
+      def rename_all_the_tables
+        strange_table_name_map.each do |name, new_name|
+          datastore.rename_table(name, new_name)
+        end
+      end
+
+      def undo_rename_all_the_tables
+        strange_table_name_map.each do |original_name, strange_name|
+          datastore.rename_table(strange_name, original_name)
+        end
+      end
+
+      def setup_the_strange_table_name_mappings
+        override_config
+          .setup_mapping(:users) do |config|
+            config.class(OpenStruct)
+            config.relation_name strange_table_name_map.fetch(:users)
+            config.has_many(:posts, foreign_key: :author_id)
+          end
+          .setup_mapping(:posts) do |config|
+            config.class(OpenStruct)
+            config.relation_name strange_table_name_map.fetch(:posts)
+            config.belongs_to(:author, mapping_name: :users)
+            config.has_many_through(:categories, through_mapping_name: strange_table_name_map.fetch(:categories_to_posts))
+          end
+          .setup_mapping(:categories) do |config|
+            config.class(OpenStruct)
+            config.relation_name strange_table_name_map.fetch(:categories)
+            config.has_many_through(:posts, through_mapping_name: strange_table_name_map.fetch(:categories_to_posts))
+          end
+      end
+
+      let(:strange_table_name_map) {
+        {
+          :users => :users_table_that_has_silly_name_perhaps_for_legacy_reasons,
+          :posts => :thank_you_past_self_for_this_excellent_name,
+          :categories => :these_are_the_categories_for_real,
+          :categories_to_posts => :this_one_is_just_full_of_bees,
+        }
+      }
+
+      it "maps data from the specified relation into a has many collection" do
+        expect(
+          user.posts.map(&:id)
+        ).to eq(["posts/1", "posts/2"])
+      end
+
+      it "maps data from the specified relation into a `belongs_to` field" do
+        expect(
+          user.posts.first.author.__getobj__.object_id
+        ).to eq(user.object_id)
+      end
+    end
+  end
+
+  context "multiple mappings for single table" do
+    TypeOneUser = Class.new(OpenStruct)
+    TypeTwoUser = Class.new(OpenStruct)
+
+    let(:override_config) {
+      Terrestrial::Configurations::ConventionalConfiguration.new(datastore)
+        .setup_mapping(:t1_users) { |c|
+          c.class(TypeOneUser)
+          c.table_name(:users)
+        }
+        .setup_mapping(:t2_users) { |c|
+          c.class(TypeTwoUser)
+          c.table_name(:users)
+        }
+    }
+
+    it "provides access to the same data via the different configs" do
+      expect(mappers[:t1_users].first.id).to eq("users/1")
+      expect(mappers[:t1_users].first).to be_a(TypeOneUser)
+      expect(mappers[:t2_users].first.id).to eq("users/1")
+      expect(mappers[:t2_users].first).to be_a(TypeTwoUser)
+    end
+  end
+end

data/spec/custom_serializers_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+require "support/have_persisted_matcher"
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "terrestrial"
+
+require "terrestrial/configurations/conventional_configuration"
+
+RSpec.describe "Config override" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  let(:user) { user_mapper.where(id: "users/1").first }
+
+  context "with an object that has private fields" do
+    let(:user_serializer) {
+      ->(object) {
+        object.to_h.merge(
+          first_name: "I am a custom serializer",
+          last_name: "and i don't care about facts",
+        )
+      }
+    }
+
+    before do
+      mappings
+        .fetch(:users)
+        .instance_variable_set(:@serializer, user_serializer)
+    end
+
+    context "when saving the object" do
+      it "uses the custom serializer" do
+        user.first_name = "This won't work"
+        user.last_name = "because the serialzer is weird"
+
+        user_mapper.save(user)
+
+        expect(datastore).to have_persisted(:users, hash_including(
+          id: user.id,
+          first_name: "I am a custom serializer",
+          last_name: "and i don't care about facts",
+        ))
+      end
+    end
+  end
+end

data/spec/deletion_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "support/have_persisted_matcher"
+require "terrestrial"
+
+RSpec.describe "Deletion" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  subject(:mapper) { user_mapper }
+
+  let(:user) {
+    mapper.where(id: "users/1").first
+  }
+
+  let(:reloaded_user) {
+    mapper.where(id: "users/1").first
+  }
+
+  describe "Deleting the root" do
+    it "deletes the root object" do
+      mapper.delete(user, cascade: true)
+
+      expect(datastore).not_to have_persisted(
+        :users,
+        hash_including(id: "users/1")
+      )
+    end
+
+    context "when much of the graph has been loaded" do
+      before do
+        user.posts.flat_map(&:comments)
+      end
+
+      it "deletes the root object" do
+        mapper.delete(user)
+
+        expect(datastore).not_to have_persisted(
+          :users,
+          hash_including(id: "users/1")
+        )
+      end
+
+      it "does not delete the child objects" do
+        expect {
+          mapper.delete(user)
+        }.not_to change { [datastore[:posts], datastore[:comments]].map(&:count) }
+      end
+    end
+
+    # context "deleting multiple" do
+    #   it "is not currently supported"
+    # end
+  end
+
+  describe "Deleting a child object (one to many)" do
+    let(:post) {
+      user.posts.find { |post| post.id == "posts/1" }
+    }
+
+    it "deletes the specified node" do
+      user.posts.delete(post)
+      mapper.save(user)
+
+      expect(datastore).not_to have_persisted(
+        :posts,
+        hash_including(id: "posts/1")
+      )
+    end
+
+    it "does not delete the parent object" do
+      user.posts.delete(post)
+      mapper.save(user)
+
+      expect(datastore).to have_persisted(
+        :users,
+        hash_including(id: "users/1")
+      )
+    end
+
+    it "does not delete the sibling objects" do
+      user.posts.delete(post)
+      mapper.save(user)
+
+      expect(reloaded_user.posts.count).to be > 0
+    end
+
+    it "does not cascade delete" do
+      expect {
+        user.posts.delete(post)
+        mapper.save(user)
+      }.not_to change {
+        datastore[:comments].map { |r| r.fetch(:id) }
+      }
+    end
+  end
+end