sequel_mapper 0.0.1 → 0.0.3

data/lib/sequel_mapper/graph.rb

@@ -1,174 +0,0 @@
-require "sequel_mapper/association_proxy"
-require "sequel_mapper/belongs_to_association_proxy"
-require "sequel_mapper/queryable_association_proxy"
-
-module SequelMapper
-  class Graph
-    def initialize(datastore:, top_level_namespace:, relation_mappings:)
-      @top_level_namespace = top_level_namespace
-      @datastore = datastore
-      @relation_mappings = relation_mappings
-    end
-
-    attr_reader :top_level_namespace, :datastore, :relation_mappings
-    private     :top_level_namespace, :datastore, :relation_mappings
-
-    def where(criteria)
-      datastore[top_level_namespace]
-        .where(criteria)
-        .map { |row|
-          load(
-            relation_mappings.fetch(top_level_namespace),
-            row,
-          )
-        }
-    end
-
-    def save(graph_root)
-      @persisted_objects = []
-      dump(top_level_namespace, graph_root)
-    end
-
-    private
-
-    def identity_map
-      @identity_map ||= {}
-    end
-
-    def dump(relation_name, object)
-      return if @persisted_objects.include?(object)
-      @persisted_objects.push(object)
-
-      relation = relation_mappings.fetch(relation_name)
-
-      row = object.to_h.select { |field_name, _v|
-        relation.fetch(:columns).include?(field_name)
-      }
-
-      relation.fetch(:belongs_to, []).each do |assoc_name, assoc_config|
-        row[assoc_config.fetch(:foreign_key)] = object.public_send(assoc_name).id
-      end
-
-      relation.fetch(:has_many, []).each do |assoc_name, assoc_config|
-        object.public_send(assoc_name).each do |assoc_object|
-          dump(assoc_config.fetch(:relation_name), assoc_object)
-        end
-
-        next unless object.public_send(assoc_name).respond_to?(:removed_nodes)
-        object.public_send(assoc_name).removed_nodes.each do |removed_node|
-          datastore[assoc_config.fetch(:relation_name)]
-            .where(id: removed_node.id)
-            .delete
-        end
-      end
-
-      relation.fetch(:has_many_through, []).each do |assoc_name, assoc_config|
-        object.public_send(assoc_name).each do |assoc_object|
-          dump(assoc_config.fetch(:relation_name), assoc_object)
-        end
-
-        next unless object.public_send(assoc_name).respond_to?(:added_nodes)
-        object.public_send(assoc_name).added_nodes.each do |added_node|
-          datastore[assoc_config.fetch(:through_relation_name)]
-            .insert(
-              assoc_config.fetch(:foreign_key) => object.id,
-              assoc_config.fetch(:association_foreign_key) => added_node.id,
-            )
-        end
-
-        object.public_send(assoc_name).removed_nodes.each do |removed_node|
-          datastore[assoc_config.fetch(:through_relation_name)]
-            .where(assoc_config.fetch(:association_foreign_key) => removed_node.id)
-            .delete
-        end
-      end
-
-      existing = datastore[relation_name]
-        .where(id: object.id)
-
-      if existing.empty?
-        datastore[relation_name].insert(row)
-      else
-        existing.update(row)
-      end
-    end
-
-    def load(relation, row)
-      previously_loaded_object = identity_map.fetch(row.fetch(:id), false)
-      return previously_loaded_object if previously_loaded_object
-
-      # puts "****************LOADING #{row.fetch(:id)}"
-
-      has_many_associations = Hash[
-        relation.fetch(:has_many, []).map { |assoc_name, assoc|
-          data_enum = datastore[assoc.fetch(:relation_name)]
-            .where(assoc.fetch(:foreign_key) => row.fetch(:id))
-
-          if assoc.fetch(:order_by, false)
-            data_enum = data_enum.order(assoc.fetch(:order_by, {}).fetch(:columns, []))
-
-            if assoc.fetch(:order_by).fetch(:direction, :asc) == :desc
-              data_enum = data_enum.reverse
-            end
-          end
-
-         [
-            assoc_name,
-            AssociationProxy.new(
-              QueryableAssociationProxy.new(
-                data_enum,
-                ->(row) {
-                  load(relation_mappings.fetch(assoc.fetch(:relation_name)), row)
-                },
-              )
-            )
-          ]
-        }
-      ]
-
-      belongs_to_associations = Hash[
-        relation.fetch(:belongs_to, []).map { |assoc_name, assoc|
-         [
-            assoc_name,
-            BelongsToAssociationProxy.new(
-              datastore[assoc.fetch(:relation_name)]
-                .where(:id => row.fetch(assoc.fetch(:foreign_key)))
-                .lazy
-                .map { |row|
-                  load(relation_mappings.fetch(assoc.fetch(:relation_name)), row)
-                }
-                .public_method(:first)
-            )
-          ]
-        }
-      ]
-
-      has_many_through_assocations = Hash[
-        relation.fetch(:has_many_through, []).map { |assoc_name, assoc|
-         [
-            assoc_name,
-            AssociationProxy.new(
-              QueryableAssociationProxy.new(
-                datastore[assoc.fetch(:relation_name)]
-                  .join(assoc.fetch(:through_relation_name), assoc.fetch(:association_foreign_key) => :id)
-                  .where(assoc.fetch(:foreign_key) => row.fetch(:id)),
-                ->(row) {
-                  load(relation_mappings.fetch(assoc.fetch(:relation_name)), row)
-                },
-              )
-            )
-          ]
-        }
-      ]
-
-      relation.fetch(:factory).call(
-        row
-          .merge(has_many_associations)
-          .merge(has_many_through_assocations)
-          .merge(belongs_to_associations)
-      ).tap { |object|
-        identity_map.store(row.fetch(:id), object)
-      }
-    end
-  end
-end

data/lib/sequel_mapper/queryable_association_proxy.rb

@@ -1,23 +0,0 @@
-class QueryableAssociationProxy
-  def initialize(database_enum, loader)
-    @database_enum = database_enum
-    @loader = loader
-  end
-
-  attr_reader :database_enum, :loader
-  private     :database_enum, :loader
-
-  extend Forwardable
-  def_delegators :database_enum, :where
-
-  def where(criteria)
-    @database_enum = database_enum.where(criteria)
-    self
-  end
-
-  def each(&block)
-    database_enum
-      .map(&loader)
-      .each(&block)
-  end
-end

data/spec/sequel_mapper/belongs_to_association_proxy_spec.rb

@@ -1,65 +0,0 @@
-require "spec_helper"
-
-require "sequel_mapper/belongs_to_association_proxy"
-
-RSpec.describe BelongsToAssociationProxy do
-  subject(:proxy) { BelongsToAssociationProxy.new(object_loader) }
-
-  let(:object_loader)   { double(:object_loader, call: proxied_object) }
-  let(:proxied_object)  { double(:proxied_object, name: name) }
-  let(:name)            { double(:name) }
-
-  describe "#__getobj__" do
-    it "loads the object" do
-      proxy.__getobj__
-
-      expect(object_loader).to have_received(:call)
-    end
-
-    it "returns the proxied object" do
-      expect(proxy.__getobj__).to be(proxied_object)
-    end
-  end
-
-  context "when no method is called on it" do
-    it "does not call the loader" do
-      proxy
-
-      expect(object_loader).not_to have_received(:call)
-    end
-  end
-
-  context "when a missing method is called on the proxy" do
-    it "is a true decorator" do
-      expect(proxied_object).to receive(:arbitrary_message)
-
-      proxy.arbitrary_message
-    end
-
-    it "loads the object" do
-      proxy.name
-
-      expect(object_loader).to have_received(:call)
-    end
-
-    it "returns delegates the message to the object" do
-      args = [ double, double ]
-      proxy.name(*args)
-
-      expect(proxied_object).to have_received(:name).with(*args)
-    end
-
-    it "returns the objects return value" do
-      expect(proxy.name).to eq(name)
-    end
-
-    context "when calling a method twice" do
-      it "loads the object once" do
-        proxy.name
-        proxy.name
-
-        expect(object_loader).to have_received(:call)
-      end
-    end
-  end
-end

data/spec/support/graph_fixture.rb

@@ -1,331 +0,0 @@
-require "support/mock_sequel"
-require "sequel_mapper/struct_factory"
-require "support/query_counter"
-
-module SequelMapper
-  module GraphFixture
-
-    # A little hack so these let blocks from an RSpec example don't have
-    # to change
-    def self.let(name, &block)
-      define_method(name) {
-        instance_variable_get("@#{name}") or
-          instance_variable_set("@#{name}", instance_eval(&block))
-      }
-    end
-
-    User = Struct.new(:id, :first_name, :last_name, :email, :posts, :toots)
-    Post = Struct.new(:id, :author, :subject, :body, :comments, :categories)
-    Comment = Struct.new(:id, :post, :commenter, :body)
-    Category = Struct.new(:id, :name, :posts)
-    Toot = Struct.new(:id, :tooter, :body, :tooted_at)
-
-    let(:query_counter) {
-      QueryCounter.new
-    }
-
-    let(:datastore) {
-      DB.tap { |db|
-        load_fixture_data(db)
-        db.loggers << query_counter
-      }
-    }
-
-    def load_fixture_data(datastore)
-      tables.each do |table, rows|
-
-        datastore.drop_table?(table)
-
-        datastore.create_table(table) do
-          rows.first.keys.each do |column|
-            String column
-          end
-        end
-
-        rows.each do |row|
-          datastore[table].insert(row)
-        end
-      end
-    end
-
-    let(:tables) {
-      {
-        users: [
-          user_1_data,
-          user_2_data,
-          user_3_data,
-        ],
-        posts: [
-          post_1_data,
-          post_2_data,
-        ],
-        comments: [
-          comment_1_data,
-          comment_2_data,
-        ],
-        categories: [
-          category_1_data,
-          category_2_data,
-        ],
-        categories_to_posts: [
-          {
-            post_id: post_1_data.fetch(:id),
-            category_id: category_1_data.fetch(:id),
-          },
-          {
-            post_id: post_1_data.fetch(:id),
-            category_id: category_2_data.fetch(:id),
-          },
-          {
-            post_id: post_2_data.fetch(:id),
-            category_id: category_2_data.fetch(:id),
-          },
-        ],
-        toots: [
-          # Toot ordering is inconsistent for scope testing.
-          toot_2_data,
-          toot_1_data,
-          toot_3_data,
-        ],
-      }
-    }
-
-    let(:relation_mappings) {
-      {
-        users: {
-          columns: [
-            :id,
-            :first_name,
-            :last_name,
-            :email,
-          ],
-          factory: user_factory,
-          has_many: {
-            posts: {
-              relation_name: :posts,
-              foreign_key: :author_id,
-            },
-            toots: {
-              relation_name: :toots,
-              foreign_key: :tooter_id,
-              order_by: {
-                columns: [:tooted_at],
-                direction: :desc,
-              },
-            },
-          },
-          # TODO: maybe combine associations like this
-          # has_many_through: {
-          #   categories_posted_in: {
-          #     through_association: [ :posts, :categories ]
-          #   }
-          # }
-        },
-        posts: {
-          columns: [
-            :id,
-            :author_id,
-            :subject,
-            :body,
-          ],
-          factory: post_factory,
-          has_many: {
-            comments: {
-              relation_name: :comments,
-              foreign_key: :post_id,
-            },
-          },
-          has_many_through: {
-            categories: {
-              through_relation_name: :categories_to_posts,
-              relation_name: :categories,
-              foreign_key: :post_id,
-              association_foreign_key: :category_id,
-            }
-          },
-          belongs_to: {
-            author: {
-              relation_name: :users,
-              foreign_key: :author_id,
-            },
-          },
-        },
-        comments: {
-          columns: [
-            :id,
-            :post_id,
-            :commenter_id,
-            :body,
-          ],
-          factory: comment_factory,
-          belongs_to: {
-            commenter: {
-              relation_name: :users,
-              foreign_key: :commenter_id,
-            },
-          },
-        },
-        categories: {
-          columns: [
-            :id,
-            :name,
-          ],
-          factory: category_factory,
-          has_many_through: {
-            posts: {
-              through_relation_name: :categories_to_posts,
-              relation_name: :posts,
-              foreign_key: :category_id,
-              association_foreign_key: :post_id,
-            }
-          },
-        },
-        toots: {
-          columns: [
-            :id,
-            :tooter_id,
-            :body,
-            :tooted_at,
-          ],
-          factory: toot_factory,
-          belongs_to: {
-            tooter: {
-              relation_name: :users,
-              foreign_key: :tooter_id,
-            },
-          },
-        },
-      }
-    }
-
-    let(:user_factory){
-      SequelMapper::StructFactory.new(User)
-    }
-
-    let(:post_factory){
-      SequelMapper::StructFactory.new(Post)
-    }
-
-    let(:comment_factory){
-      SequelMapper::StructFactory.new(Comment)
-    }
-
-    let(:category_factory){
-      SequelMapper::StructFactory.new(Category)
-    }
-
-    let(:toot_factory){
-      SequelMapper::StructFactory.new(Toot)
-    }
-
-    let(:user_1_data) {
-      {
-        id: "user/1",
-        first_name: "Stephen",
-        last_name: "Best",
-        email: "bestie@gmail.com",
-      }
-    }
-
-    let(:user_2_data) {
-      {
-        id: "user/2",
-        first_name: "Hansel",
-        last_name: "Trickett",
-        email: "hansel@gmail.com",
-      }
-    }
-
-    let(:user_3_data) {
-      {
-        id: "user/3",
-        first_name: "Jasper",
-        last_name: "Trickett",
-        email: "jasper@gmail.com",
-      }
-    }
-
-    let(:post_1_data) {
-      {
-        id: "post/1",
-        author_id: "user/1",
-        subject: "Object mapping",
-        body: "It is often tricky",
-      }
-    }
-
-    let(:post_2_data) {
-      {
-        id: "post/2",
-        author_id: "user/1",
-        subject: "Object mapping part 2",
-        body: "Lazy load all the things!",
-      }
-    }
-
-    let(:comment_1_data) {
-      {
-        id: "comment/1",
-        post_id: "post/1",
-        commenter_id: "user/2",
-        body: "Trololol",
-      }
-    }
-
-    let(:comment_2_data) {
-      {
-        id: "comment/2",
-        post_id: "post/1",
-        commenter_id: "user/1",
-        body: "You are so LOL",
-      }
-    }
-
-    let(:category_1_data) {
-      {
-        id: "category/1",
-        name: "good",
-      }
-    }
-
-    let(:category_2_data) {
-      {
-        id: "category/2",
-        name: "bad",
-      }
-    }
-
-    let(:category_3_data) {
-      {
-        id: "category/3",
-        name: "ugly",
-      }
-    }
-
-    let(:toot_1_data) {
-      {
-        id: "toot/1",
-        tooter_id: "user/1",
-        body: "Armistice toots",
-        tooted_at: Time.parse("2014-11-11 11:11:00 UTC").iso8601,
-      }
-    }
-    let(:toot_2_data) {
-      {
-        id: "toot/2",
-        tooter_id: "user/1",
-        body: "Tooting every second",
-        tooted_at: Time.parse("2014-11-11 11:11:01 UTC").iso8601,
-      }
-    }
-
-    let(:toot_3_data) {
-      {
-        id: "toot/3",
-        tooter_id: "user/1",
-        body: "Join me in a minutes' toots",
-        tooted_at: Time.parse("2014-11-11 11:11:02 UTC").iso8601,
-      }
-    }
-  end
-end