sequel_mapper 0.0.1 → 0.0.3

data/lib/sequel_mapper/serializer.rb

@@ -0,0 +1,18 @@
+module SequelMapper
+  class Serializer
+    def initialize(field_names, object)
+      @field_names = field_names
+      @object = object
+    end
+
+    attr_reader :field_names, :object
+
+    def to_h
+      Hash[
+        field_names.map { |field_name|
+          [field_name, object.public_send(field_name)]
+        }
+      ]
+    end
+  end
+end

data/lib/sequel_mapper/short_inspection_string.rb

@@ -0,0 +1,18 @@
+module SequelMapper
+  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/sequel_mapper/subset_queries_proxy.rb

@@ -0,0 +1,11 @@
+module SequelMapper
+  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/sequel_mapper/upserted_record.rb

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

data/lib/sequel_mapper/version.rb

@@ -1,3 +1,3 @@
 module SequelMapper
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/sequel_mapper.gemspec

@@ -22,7 +22,10 @@ Gem::Specification.new do |spec|
   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,167 @@
+require "spec_helper"
+
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "sequel_mapper"
+
+require "sequel_mapper/configurations/conventional_configuration"
+
+RSpec.describe "Configuration override" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  subject(:user_mapper) {
+    SequelMapper.mapper(
+      config: mapper_config,
+      name: :users,
+      datastore: datastore,
+    )
+  }
+
+  let(:mapper_config) {
+    SequelMapper::Configurations::ConventionalConfiguration.new(datastore)
+      .setup_mapping(:users) { |users|
+        users.has_many :posts, foreign_key: :author_id
+      }
+  }
+
+  let(:user) {
+    user_mapper.where(id: "users/1").first
+  }
+
+  context "override the root mapper factory" do
+    context "with a Struct class" do
+      before do
+        mapper_config.setup_mapping(:users) do |config|
+          config.class(user_subclass)
+        end
+      end
+
+      let(:user_subclass) { Class.new(User) }
+
+      it "uses the class from the override" do
+        expect(user.class).to be(user_subclass)
+      end
+    end
+  end
+
+  context "override an association" do
+    context "with a callable factory" do
+      before do
+        mapper_config.setup_mapping(:posts) do |config|
+          config.factory(override_post_factory)
+        end
+      end
+
+      let(:post_subclass) { Class.new(Post) }
+
+      let(:override_post_factory) {
+        SequelMapper::StructFactory.new(post_subclass)
+      }
+
+      let(:posts) {
+        user.posts
+      }
+
+      it "uses the specified factory" do
+        expect(posts.first.class).to be(post_subclass)
+      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(:mapper_config) {
+        SequelMapper::Configurations::ConventionalConfiguration
+        .new(datastore)
+        .setup_mapping(:users) do |config|
+          config.relation_name unconventional_table_name
+        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
+        mapper_config
+          .setup_mapping(:users) do |config|
+            config.relation_name strange_table_name_map.fetch(:users)
+            config.has_many(:posts, foreign_key: :author_id)
+          end
+          .setup_mapping(:posts) do |config|
+            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.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
+end

data/spec/custom_serializers_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+require "support/have_persisted_matcher"
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "sequel_mapper"
+
+require "sequel_mapper/configurations/conventional_configuration"
+
+RSpec.describe "Config override" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+
+  subject(:user_mapper) {
+    SequelMapper.mapper(
+      config: mapper_config,
+      name: :users,
+      datastore: datastore,
+    )
+  }
+
+  let(:mapper_config) {
+    SequelMapper::Configurations::ConventionalConfiguration.new(datastore)
+      .setup_mapping(:users) { |users|
+        users.has_many :posts, foreign_key: :author_id
+      }
+  }
+
+  let(:user) { user_mapper.where(id: "users/1").first }
+
+  context "with an object that has private fields" do
+    let(:user_class) {
+      Class.new(User) {
+        private :first_name
+        private :last_name
+
+        def full_name
+          [first_name, last_name].join(" ")
+        end
+      }
+    }
+
+    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
+      mapper_config.setup_mapping(:users) do |config|
+        config.class(user_class)
+        config.serializer(user_serializer)
+      end
+    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,104 @@
+require "spec_helper"
+
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "support/have_persisted_matcher"
+require "sequel_mapper"
+
+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)
+
+      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
+      user.posts.delete(post)
+      mapper.save(user)
+
+      expect(datastore).to have_persisted(
+        :comments,
+        hash_including(
+          post_id: "posts/1",
+        )
+      )
+    end
+  end
+end

data/spec/graph_persistence_spec.rb

@@ -1,34 +1,33 @@
 require "spec_helper"
 
+require "support/have_persisted_matcher"
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
 require "sequel_mapper"
-require "support/graph_fixture"
 
 RSpec.describe "Graph persistence" do
-  include SequelMapper::GraphFixture
-
-  subject(:graph) {
-    SequelMapper::Graph.new(
-      top_level_namespace: :users,
-      datastore: datastore,
-      relation_mappings: relation_mappings,
-    )
-  }
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  subject(:mapper) { mappers.fetch(:users) }
 
   let(:user) {
-    graph.where(id: "user/1").fetch(0)
+    mapper.where(id: "users/1").first
   }
 
-  context "without accessing associations" do
+  context "without associations" do
     let(:modified_email) { "bestie+modified@gmail.com" }
 
     it "saves the root object" do
       user.email = modified_email
-      graph.save(user)
+      mapper.save(user)
 
       expect(datastore).to have_persisted(
         :users,
         hash_including(
-          id: "user/1",
+          id: "users/1",
           email: modified_email,
         )
       )
@@ -36,7 +35,7 @@ RSpec.describe "Graph persistence" do
 
     it "doesn't send associated objects to the database as columns" do
       user.email = modified_email
-      graph.save(user)
+      mapper.save(user)
 
       expect(datastore).not_to have_persisted(
         :users,
@@ -45,6 +44,23 @@ RSpec.describe "Graph persistence" do
         )
       )
     end
+
+    # TODO move to a dirty tracking spec?
+    context "when mutating entity fields in place" do
+      it "saves the object" do
+        user.email << "MUTATED"
+
+        mapper.save(user)
+
+        expect(datastore).to have_persisted(
+          :users,
+          hash_including(
+            id: "users/1",
+            email: /MUTATED$/,
+          )
+        )
+      end
+    end
   end
 
   context "modify shallow has many associated object" do
@@ -53,14 +69,14 @@ RSpec.describe "Graph persistence" do
 
     it "saves the associated object" do
       post.body = modified_post_body
-      graph.save(user)
+      mapper.save(user)
 
       expect(datastore).to have_persisted(
         :posts,
         hash_including(
           id: post.id,
           subject: post.subject,
-          author_id: post.author.id,
+          author_id: user.id,
           body: modified_post_body,
         )
       )
@@ -69,22 +85,22 @@ RSpec.describe "Graph persistence" do
 
   context "modify deeply nested has many associated object" do
     let(:comment) {
-      user.posts.first.comments.to_a.last
+      user.posts.first.comments.first
     }
 
     let(:modified_comment_body) { "body moving, body moving" }
 
     it "saves the associated object" do
       comment.body = modified_comment_body
-      graph.save(user)
+      mapper.save(user)
 
       expect(datastore).to have_persisted(
         :comments,
         hash_including(
           {
-            id: "comment/2",
-            post_id: "post/1",
-            commenter_id: "user/1",
+            id: "comments/1",
+            post_id: "posts/1",
+            commenter_id: "users/1",
             body: modified_comment_body,
           }
         )
@@ -92,41 +108,6 @@ RSpec.describe "Graph persistence" do
     end
   end
 
-  context "modify the foreign_key of an object" do
-    let(:original_author) { user }
-    let(:new_author)      { graph.where(id: "user/2").first }
-    let(:post)            { original_author.posts.first }
-
-    it "persists the change in ownership" do
-      post.author = new_author
-      graph.save(user)
-
-      expect(datastore).to have_persisted(
-        :posts,
-        hash_including(
-          id: post.id,
-          author_id: new_author.id,
-        )
-      )
-    end
-
-    it "removes the object form the original graph" do
-      post.author = new_author
-      graph.save(user)
-
-      expect(original_author.posts.to_a.map(&:id))
-        .not_to include("posts/1")
-    end
-
-    it "adds the object to the appropriate graph" do
-      post.author = new_author
-      graph.save(user)
-
-      expect(new_author.posts.to_a.map(&:id))
-        .to include("post/1")
-    end
-  end
-
   context "add a node to a has many assocation" do
     let(:new_post_attrs) {
       {
@@ -141,7 +122,7 @@ RSpec.describe "Graph persistence" do
 
     let(:new_post) {
       SequelMapper::StructFactory.new(
-        SequelMapper::GraphFixture::Post
+        Post
       ).call(new_post_attrs)
     }
 
@@ -153,7 +134,8 @@ RSpec.describe "Graph persistence" do
 
     it "persists the object" do
       user.posts.push(new_post)
-      graph.save(user)
+
+      mapper.save(user)
 
       expect(datastore).to have_persisted(
         :posts,
@@ -166,18 +148,18 @@ RSpec.describe "Graph persistence" do
     end
   end
 
-  context "remove an object from a has many association" do
+  context "delete an object from a has many association" do
     let(:post) { user.posts.first }
 
-    it "removes the object from the graph" do
-      user.posts.remove(post)
+    it "delete the object from the graph" do
+      user.posts.delete(post)
 
       expect(user.posts.map(&:id)).not_to include(post.id)
     end
 
-    it "removes the object from the datastore on save" do
-      user.posts.remove(post)
-      graph.save(user)
+    it "delete the object from the datastore on save" do
+      user.posts.delete(post)
+      mapper.save(user)
 
       expect(datastore).not_to have_persisted(
         :posts,
@@ -188,21 +170,21 @@ RSpec.describe "Graph persistence" do
     end
   end
 
-  context "modify a many to many relationhip" do
+  context "modify a many to many relationship" do
     let(:post)     { user.posts.first }
 
-    context "remove a node" do
+    context "delete a node" do
       it "mutates the graph" do
         category = post.categories.first
-        post.categories.remove(category)
+        post.categories.delete(category)
 
         expect(post.categories.map(&:id)).not_to include(category.id)
       end
 
-      it "persists the change" do
+      it "deletes the 'join table' record" do
         category = post.categories.first
-        post.categories.remove(category)
-        graph.save(user)
+        post.categories.delete(category)
+        mapper.save(user)
 
         expect(datastore).not_to have_persisted(
           :categories_to_posts,
@@ -212,6 +194,19 @@ RSpec.describe "Graph persistence" do
           }
         )
       end
+
+      it "does not delete the object" do
+        category = post.categories.first
+        post.categories.delete(category)
+        mapper.save(user)
+
+        expect(datastore).to have_persisted(
+          :categories,
+          hash_including(
+            id: category.id,
+          )
+        )
+      end
     end
 
     context "add a node" do
@@ -222,12 +217,12 @@ RSpec.describe "Graph persistence" do
         post_with_one_category.categories.push(new_category)
 
         expect(post_with_one_category.categories.map(&:id))
-          .to match_array(["category/1", "category/2"])
+          .to match_array(["categories/1", "categories/2"])
       end
 
       it "persists the change" do
         post_with_one_category.categories.push(new_category)
-        graph.save(user)
+        mapper.save(user)
 
         expect(datastore).to have_persisted(
           :categories_to_posts,
@@ -252,7 +247,7 @@ RSpec.describe "Graph persistence" do
 
       it "persists the change" do
         category.name = modified_category_name
-        graph.save(user)
+        mapper.save(user)
 
         expect(datastore).to have_persisted(
           :categories,
@@ -265,23 +260,23 @@ RSpec.describe "Graph persistence" do
     end
   end
 
-  RSpec::Matchers.define :have_persisted do |relation_name, data|
-    match do |datastore|
-      datastore[relation_name].find { |record|
-        if data.respond_to?(:===)
-          data === record
-        else
-          data == record
-        end
-      }
+  context "when a save operation fails (some object is not persistable)" do
+    before do
+      user.posts.first.subject = "UNRELATED CHANGE THAT WILL FAIL"
+      user.email = unpersistable_object
     end
 
-    failure_message do |datastore|
-      "expected #{datastore[relation_name]} to have persisted #{data.inspect} in #{relation_name}"
-    end
+    let(:unpersistable_object) { ->() { } }
+
+    it "rolls back the transation" do
+      begin
+        mapper.save(user)
+      rescue Sequel::Error
+      end
 
-    failure_message_when_negated do |datastore|
-      failure_message.gsub("to have", "not to have")
+      expect(datastore).not_to have_persisted(:posts, hash_including(
+        subject: "UNRELATED CHANGE THAT WILL FAIL"
+      ))
     end
   end
 end