sequel_mapper 0.0.1 → 0.0.3

data/TODO.md

@@ -3,16 +3,8 @@
 In no particular order
 
 ## General
-* Refactor, methods too, big objects missing
-
-## Persistence
-* Efficient saving
-  - Part one, if it wasn't loaded it wasn't modified, check identity map
-  - Part two, dirty tracking
-
-## Configuration
-* Automatic config generation based on schema, foreign keys etc
-* Config to take either a classes or callable factory
+* Refactor, methods too big, objects missing
+* Name things better
 
 ## Querying
 * Querying API, what would a repository with some arbitrary queries look like?
@@ -24,10 +16,23 @@ In no particular order
   Sequel's `#where` with block [querying API](http://sequel.jeremyevans.net/rdoc/files/doc/cheat_sheet_rdoc.html#label-AND%2FOR%2FNOT)
 
 ## Associations
-* Eager loading
 * Read only associations
   - Loaded objects would be immutable
   - Collection proxy would have no #push or #remove
   - Skipped when dumping
 * Associations defined with a join
 * Composable associations
+
+# Hopefully done
+
+## Persistence
+* Efficient saving
+  - Part one, if it wasn't loaded it wasn't modified, check identity map
+  - Part two, dirty tracking
+
+## Associations
+* Eager loading
+
+## Configuration
+* Automatic config generation based on schema, foreign keys etc
+* Config to take either a classes or callable factory

data/features/env.rb

@@ -0,0 +1,57 @@
+require "pry"
+require "sequel"
+require "sequel_mapper"
+require_relative "../spec/support/sequel_test_support"
+
+module ExampleRunnerSupport
+  def example_eval_concat(code_strings)
+    example_eval(code_strings.join("\n"))
+  end
+
+  def example_eval(code_string)
+    example_module.module_eval(code_string)
+  rescue Object => e
+    binding.pry if ENV["DEBUG"]
+    raise e
+  end
+
+  def example_exec(&block)
+    example_exec.module_eval(&block)
+  end
+
+  def example_module
+    @example_module ||= Module.new
+  end
+
+  def normalise_inspection_string(string)
+    string
+      .strip
+      .gsub(/[\n\s]+/, " ")
+      .gsub(/\:[0-9a-f]{12}/, ":<<object id removed>>")
+  end
+
+  def parse_schema_table(string)
+    string.each_line.drop(2).map { |line|
+      name, type = line.split("|").map(&:strip)
+      {
+        name: name,
+        type: type,
+      }
+    }
+  end
+end
+
+module DatabaseSupport
+  def create_table(name, schema)
+    SequelMapper::SequelTestSupport.create_tables(
+      name => schema,
+    )
+  end
+end
+
+Before do
+  SequelMapper::SequelTestSupport.drop_tables
+end
+
+World(ExampleRunnerSupport)
+World(DatabaseSupport)

data/features/example.feature

@@ -0,0 +1,121 @@
+Feature: Basic setup
+
+  Scenario: Setup with conventional configuration
+    Given the domain objects are defined
+      """
+        User = Struct.new(:id, :first_name, :last_name, :email, :posts)
+        Post = Struct.new(:id, :author, :subject, :body, :created_at, :categories)
+        Category = Struct.new(:id, :name, :posts)
+      """
+    And a conventionally similar database schema for table "users"
+      """
+        Column      | Type
+       ------------ +---------
+        id          | text
+        first_name  | text
+        last_name   | text
+        email       | text
+      """
+    And a conventionally similar database schema for table "posts"
+      """
+        Column      | Type
+       -------------+---------
+        id          | text
+        author_id   | text
+        subject     | text
+        body        | text
+        created_at  | DateTime
+      """
+    And a conventionally similar database schema for table "categories"
+      """
+        Column      | Type
+       -------------+---------
+        id          | text
+        name        | text
+      """
+    And a conventionally similar database schema for table "categories_to_posts"
+      """
+        Column      | Type
+       -------------+---------
+        post_id     | text
+        category_id | text
+      """
+    And a database connection is established
+      """
+        DB = Sequel.postgres(
+          host: ENV.fetch("PGHOST"),
+          user: ENV.fetch("PGUSER"),
+          database: ENV.fetch("PGDATABASE"),
+        )
+      """
+    And the associations are defined in the mapper configuration
+      """
+      USER_MAPPER_CONFIG = SequelMapper.config(DB)
+        .setup_mapping(:users) { |users|
+          users.class(User)
+          users.has_many(:posts, foreign_key: :author_id)
+        }
+        .setup_mapping(:posts) { |posts|
+          posts.class(Post)
+          posts.belongs_to(:author, mapping_name: :users)
+          posts.has_many_through(:categories)
+        }
+        .setup_mapping(:categories) { |categories|
+          categories.class(Category)
+          categories.has_many_through(:posts)
+        }
+      """
+    And a mapper is instantiated
+      """
+        USER_MAPPER = SequelMapper.mapper(
+          datastore: DB,
+          config: USER_MAPPER_CONFIG,
+          name: :users,
+        )
+      """
+    When a new graph of objects are created
+      """
+        user = User.new(
+          "2f0f791c-47cf-4a00-8676-e582075bcd65",
+          "Hansel",
+          "Trickett",
+          "hansel@tricketts.org",
+          [],
+        )
+
+        user.posts << Post.new(
+          "9b75fe2b-d694-4b90-9137-6201d426dda2",
+          user,
+          "Things that I like",
+          "I like fish and scratching",
+          Time.parse("2015-10-03 21:00:00 UTC"),
+          [],
+        )
+      """
+    And the new graph is saved
+      """
+        USER_MAPPER.save(user)
+      """
+    And the following query is executed
+      """
+        user = USER_MAPPER.where(id: "2f0f791c-47cf-4a00-8676-e582075bcd65").first
+      """
+    Then the persisted user object is returned with lazy associations
+      """
+        #<struct User id="2f0f791c-47cf-4a00-8676-e582075bcd65",
+          first_name="Hansel",
+          last_name="Trickett",
+          email="hansel@tricketts.org",
+          posts=#<SequelMapper::CollectionMutabilityProxy:7fa4817aa148
+        >>
+      """
+    And the user's posts will be loaded once the association proxy receives an Enumerable message
+      """
+        [#<struct Post id="9b75fe2b-d694-4b90-9137-6201d426dda2",
+          author=#<SequelMapper::LazyObjectProxy:7fec5ac2a5f8 known_fields={:id=>"2f0f791c-47cf-4a00-8676-e582075bcd65"} lazy_object=nil>,
+          subject="Things that I like",
+          body="I like fish and scratching",
+          created_at=2015-10-03 21:00:00 UTC,
+          categories=#<SequelMapper::CollectionMutabilityProxy:7fec5ac296f8
+        >>]
+      """

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/sequel_mapper.rb

@@ -1,4 +1,8 @@
+require "logger"
+require "sequel_mapper/public_conveniencies"
+
 module SequelMapper
-end
+  extend PublicConveniencies
 
-require "sequel_mapper/graph"
+  LOGGER = Logger.new(STDERR)
+end

data/lib/sequel_mapper/abstract_record.rb

@@ -0,0 +1,53 @@
+require "forwardable"
+
+module SequelMapper
+  class AbstractRecord
+    extend Forwardable
+
+    def initialize(namespace, identity, raw_data = {})
+      @namespace = namespace
+      @identity = identity
+      @raw_data = raw_data
+    end
+
+    attr_reader :namespace, :identity
+
+    attr_reader :raw_data
+    private     :raw_data
+
+    def_delegators :to_h, :fetch
+
+    def if_upsert(&block)
+      self
+    end
+
+    def if_delete(&block)
+      self
+    end
+
+    def merge(more_data)
+      new_with_raw_data(raw_data.merge(more_data))
+    end
+
+    def to_h
+      raw_data.merge(identity)
+    end
+
+    def ==(other)
+      self.class === other &&
+        [operation, to_h] == [other.operation, other.to_h]
+    end
+
+    protected
+
+    def operation
+      raise NotImplementedError
+    end
+
+    private
+
+    def new_with_raw_data(new_raw_data)
+      self.class.new(namespace, identity, new_raw_data)
+    end
+  end
+end

data/lib/sequel_mapper/association_loaders.rb

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

@@ -0,0 +1,77 @@
+require "forwardable"
+require "sequel_mapper/short_inspection_string"
+
+module SequelMapper
+  class CollectionMutabilityProxy
+    include ShortInspectionString
+
+    def initialize(collection)
+      @collection = collection
+      @added_nodes = []
+      @deleted_nodes = []
+    end
+
+    attr_reader :collection, :deleted_nodes, :added_nodes
+    private     :collection, :deleted_nodes, :added_nodes
+
+    extend Forwardable
+    def_delegators :collection, :where, :subset
+
+    def each_loaded(&block)
+      loaded_enum.each(&block)
+    end
+
+    def each_deleted(&block)
+      @deleted_nodes.each(&block)
+    end
+
+    include Enumerable
+    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