sequel_mapper 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2a26f63ff570a4dace02b8407237d137e91fcc86
+  data.tar.gz: 682421f11a6baccefbe7969510f345d17ea26d71
+SHA512:
+  metadata.gz: ebc65d4a2915be9f85d269c417f47d96bec45255601a8a389b88c5bdc009420fac2c9f65ad64c8cdb13fea33a877b3d8db0274264e6f3242cd2cff3f207a6111
+  data.tar.gz: 6742b37bb795d34aeadc8fd765bc76976cafcf0e5c1b24873dc5720d1631b07cca1391c3914774acb4b8026514830ea13dcd9bcb7a35d2cb762042fc712898b3

data/.gitignore

@@ -0,0 +1 @@
+.env

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+2.1.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sequel_mapper.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    sequel_mapper (0.0.1)
+      sequel (~> 4.16)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    method_source (0.8.2)
+    pg (0.17.1)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.1.0)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    sequel (4.16.0)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.7)
+  pg (~> 0.17.1)
+  pry (~> 0.10.1)
+  rake (~> 10.0)
+  rspec (~> 3.1)
+  sequel_mapper!

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Stephen Best
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,112 @@
+# SequelMapper
+
+**Very new, much experimental, so incomplete**
+
+## What it is
+
+SequelMapper is a data mapper that pulls rows out of your database and maps
+them into a graph of plain Ruby objects. The graph can then be modifed and
+persisted back into the database as a whole.
+
+The main feature is that it fully supports all the kinds of data associations
+that you are used to with ActiveRecord but for your POROs.
+
+It is built on top of Jeremy Evans' Sequel library.
+
+## Why is it?
+
+* It seems like ROM may not be finished any time soon and I felt I could put
+  together something functional albeit less ambitious
+* I love the Sequel library
+* I love decoupling persistence
+* Writing a complex datamapper is sure way to stall your project so I'm writing
+  one for you
+* I am a sick person who enjoys this sort of thing
+
+So go on, persist those POROs, they don't even have to know about it.
+
+## Example
+
+```ruby
+  # Let's say you have some domain objects
+
+  User = Struct.new(:id, :first_name, :last_name, :email, :posts)
+  Post = Struct.new(:id, :author, :subject, :body, :comments, :categories)
+  Comment = Struct.new(:id, :post, :commenter, :body)
+  Category = Struct.new(:id, :name, :posts)
+
+  # And a relational database with some tables that look similar
+
+  DB = Sequel.postgres(
+    host: ENV.fetch("PGHOST"),
+    user: ENV.fetch("PGUSER"),
+    database: ENV.fetch("PGDATABASE"),
+  )
+
+  user_mapper = SequelMapper::Graph.new(
+    top_level_namespace: :users,
+    datastore: DB,
+    config: mapper_config, # Config omitted
+  )
+
+  # Then this may appeal to you
+
+  user = user_mapper.where(id: 1).first
+  # => [#<struct User
+  #       id=1,
+  #       first_name="Stephen",
+  #       last_name="Best",
+  #       email="bestie@gmail.com",
+  #       posts=#<SequelMapper::AssociationProxy:0x007ffbc3c7cb50 @assoc_enum=#<Enumerator::Lazy: ...>, @removed_nodes=[]>>]
+
+  user.posts
+  # => #<SequelMapper::AssociationProxy:0x007ffbc3c7cb50 @assoc_enum=#<Enumerator::Lazy: ...>, @removed_nodes=[]>
+  # That's lazily evaluated try ...
+
+  user.posts.to_a
+  # => [#<struct Post
+  #       id=1,
+  #       author=
+  #        #<struct User
+  #         id=1,
+  #         first_name="Stephen",
+  #         last_name="Best",
+  #         email="bestie@gmail.com",
+  #         posts=#<SequelMapper::AssociationProxy:0x007ffbc3c7cb50 @assoc_enum=#<Enumerator::Lazy: ...>, @removed_nodes=[]>>,
+  #       subject="Object mapping",
+  #       body="It is often tricky",
+  #       comments=#<SequelMapper::AssociationProxy:0x007ffbc59377b8 @assoc_enum=#<Enumerator::Lazy: ...>, @removed_nodes=[]>,
+  #       categories=#<SequelMapper::AssociationProxy:0x007ffbc5936138 @assoc_enum=#<Enumerator::Lazy: ...>, @removed_nodes=[]>>,
+  #      #<struct Post
+  #       id=2,
+  #       author=
+  #        #<struct User
+  #         id=1,
+  #         first_name="Stephen",
+  #         last_name="Best",
+  #         email="bestie@gmail.com",
+  #         posts=#<SequelMapper::AssociationProxy:0x007ffbc3c7cb50 @assoc_enum=#<Enumerator::Lazy: ...>, @removed_nodes=[]>>,
+  #       subject="Object mapping part 2",
+  #       body="Lazy load all the things!",
+  #       comments=#<SequelMapper::AssociationProxy:0x007ffbc5935990 @assoc_enum=#<Enumerator::Lazy: ...>, @removed_nodes=[]>,
+  #       categories=#<SequelMapper::AssociationProxy:0x007ffbc592fe50 @assoc_enum=#<Enumerator::Lazy: ...>, @removed_nodes=[]>>]
+
+  # And then access the comments and so on ...
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sequel_mapper'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sequel_mapper
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/TODO.md

@@ -0,0 +1,33 @@
+# TODOs
+
+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
+
+## Querying
+* Querying API, what would a repository with some arbitrary queries look like?
+  - e.g. an association on post called `burger_comments` that finds comments
+    with the word burger in them
+* Add other querying methods from assocaition proxies or remove entirely
+  - Depends on nailing down the querying API
+* When possible optimise blocks given to `AssociationProxy#select` with
+  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

data/lib/sequel_mapper.rb

@@ -0,0 +1,4 @@
+module SequelMapper
+end
+
+require "sequel_mapper/graph"

data/lib/sequel_mapper/association_proxy.rb

@@ -0,0 +1,54 @@
+require "forwardable"
+
+module SequelMapper
+  class AssociationProxy
+    def initialize(assoc_enum)
+      @assoc_enum = assoc_enum
+      @added_nodes = []
+      @removed_nodes = []
+    end
+
+    attr_reader :assoc_enum, :removed_nodes, :added_nodes
+    private     :assoc_enum
+
+    include Enumerable
+    def each(&block)
+      enum = Enumerator.new do |yielder|
+        assoc_enum.each do |element|
+          yielder.yield(element) unless removed?(element)
+        end
+
+        @added_nodes.each do |node|
+          yielder.yield(node)
+        end
+      end
+
+      if block
+        enum.each(&block)
+        self
+      else
+        enum
+      end
+    end
+
+    def remove(node)
+      @removed_nodes.push(node)
+      self
+    end
+
+    def push(node)
+      @added_nodes.push(node)
+    end
+
+    def where(criteria)
+      @assoc_enum.where(criteria)
+      self
+    end
+
+    private
+
+    def removed?(node)
+      @removed_nodes.include?(node)
+    end
+  end
+end

data/lib/sequel_mapper/belongs_to_association_proxy.rb

@@ -0,0 +1,27 @@
+require "delegate"
+
+class BelongsToAssociationProxy < SimpleDelegator
+  def initialize(object_loader)
+    @object_loader = object_loader
+    @loaded = false
+  end
+
+  def method_missing(method_id, *args, &block)
+    __load_object__
+
+    super
+  end
+
+  def __getobj__
+    __load_object__
+    super
+  end
+
+  private
+
+  def __load_object__
+    __setobj__(@object_loader.call).tap {
+      @loaded = true
+    } unless @loaded
+  end
+end

data/lib/sequel_mapper/graph.rb

@@ -0,0 +1,174 @@
+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