jet_set 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9d9c31fea3ab85535b7334a1bcfea9f5a15577f6
-  data.tar.gz: 9dff8880d96dc20c7674a64e66553ac104da18be
+SHA256:
+  metadata.gz: 4c2b21527242c8574e604c1ece2b26ec71d59c7712b76cdfa9e88fdc6a47265b
+  data.tar.gz: bdcba0c32be1c7db5a0b63f206dd7c5e354c30a9af14eb1b0b204a55ea4ce349
 SHA512:
-  metadata.gz: 23b7ed643ec6ad827879e7d6f2e1e9d0f038a78cd7051483de3c85f6ea1f32d02361d098ecbeab6648375b5d206367028bdd16310ca8a11bd76962ece12b0258
-  data.tar.gz: c59832f80bbf2996665384963be940e81ae9bc26a68a28f6d5bb212e28c1899710c544cfb5eeff48564e5a9a7458453eddaa475708d5ad11809a765111bb8964
+  metadata.gz: b6e155d9e2c20157beb3689764a42f8618159fb443b11c41d2ae81a5405fc3fadb55e31a562fcbf58fb0e06a78bf8611ea10eb36378c2b14e4c3e59c6e5b409b
+  data.tar.gz: 076a5aa11cb87fa6773faca5d3b92e218e5e939a6808d1825486c8cc1c8428cbeb1b480fe152f69a3e6f09b9f5431b4ebbec70873c567a44e91c6439f8150120

data/Gemfile

@@ -2,4 +2,3 @@ source "https://rubygems.org"
 
 gemspec
 
-

data/README.md

@@ -1,9 +1,8 @@
 # JetSet ![Build Status](https://travis-ci.org/cylon-v/jet_set.svg?branch=master)
 
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/jet_set`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+JetSet is a data mapping framework for domain-driven developers who think that SQL is the best tool for data querying.
+JetSet is built on top of [Sequel](https://github.com/jeremyevans/sequel) ORM and it's just an abstraction for making 
+the persistence of mapped objects invisible.  
 
 ## Installation
 
@@ -23,7 +22,123 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Initialization
+Open DB connection, see [Sequel docs](https://sequel.jeremyevans.net/rdoc/files/doc/opening_databases_rdoc.html):
+```ruby
+ @connection = Sequel.connect('sqlite:/') # you can connect to any DB supported by Sequel
+```
+
+Create a mapping of your model, a details described [here]:
+```ruby
+class Mapping
+  def self.load_mapping
+    JetSet::map do
+      entity User do
+        field :first_name # reqular field
+        collection :invoices, type: Invoice # "has many" association
+        reference :plan, type: Plan, weak: true # "belongs to" association
+      end
+    end
+  end
+end
+```
+
+Init JetSet environment on start of your application:
+```ruby
+JetSet::init(Mapping.load_mapping, @container)
+```
+
+Open JetSet session:
+```ruby
+@jet_set = JetSet::open_session(@connection)
+```
+For web-applications it's reasonable to bind JetSet session to request lifetime - 
+all modification operations in an MVC action can represent a ["Unit of Work"](https://martinfowler.com/eaaCatalog/unitOfWork.html).
+
+### Object model
+Using JetSet you can wrap an application domain model and purely implement "Persistence Ignorance" approach. 
+The model objects are pure Ruby objects without any noisy stuff like annotations, inline mapping, etc:
+```ruby
+class User
+  attr_reader :invoices
+
+  def initialize(attrs = {})
+    @first_name = attrs[:first_name]
+    @last_name = attrs[:last_name]
+    @invoices = []
+  end
+
+  def add_invoice(invoice)
+    @invoices << invoice
+  end
+end
+
+class Invoice
+  attr_reader :created_at, :amount
+
+  def initialize(attrs = {})
+    @created_at = DateTime.now
+    @amount = attrs[:amount] || 0
+  end
+end
+```
+
+### Object model tracking and saving
+Create an objects which is described in the mapping:
+```ruby
+user = User.new(first_name: 'Ivan', last_name: 'Ivanov')
+invoice = Invoice.new(created_at: DateTime.now, user: user, amount: 100.0)
+```
+
+Attach them to the session:
+```ruby
+ @session.attach(invoice, user)
+```
+It makes the objects tracked by JetSet.
+
+Finalize the session:
+```ruby
+ @session.finalize
+```
+It saves all added/changed objects to the database.
+
+### Object model loading
+
+```ruby
+user_query = <<~SQL
+  SELECT
+    u.* AS ENTITY user
+  FROM users u
+  LIMIT 1
+SQL
+
+invoices_sql = <<~SQL
+  SELECT
+    i.* AS ENTITY invoice
+  WHERE i.user_id = :user_id
+SQL
+
+customer = @session.fetch(User, user_query) do |user|
+  preload(user, :invoices, invoices_sql, user_id: user.id)
+end
+```
+All loaded objects are already attached to the session and you can perform a changes which will be saved after the session finalization:
+
+```ruby
+customer.invoices[0].apply # changes invoice state
+@session.finalize
+```
+
+Do not load your object model just for drawing a views. For showing a results just use Sequel without any object mappings:
+```ruby
+result = @connection[:user].where(role: 'admin').to_a
+json = JSON.generate(data: result)
+```   
+In other words, following [CQS](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation) approach you can 
+load your model for a command but not for a query.
+
+You can find more interesting examples in [JetSet integration tests](https://github.com/cylon-v/jet_set/tree/master/spec/integration).        
+Also for the details please visit our [wiki].
 
 ## Development
 

data/jet_set.gemspec

@@ -31,8 +31,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'sequel', '~> 5.4.0'
-  spec.add_dependency 'hypo', '~> 0.9.0'
-
+  spec.add_dependency 'hypo', '~> 0.10.0'
   spec.add_development_dependency 'bundler', '~> 1.15'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'

data/lib/jet_set/mapper.rb

@@ -31,20 +31,26 @@ module JetSet
       entity_name = type.name.underscore.to_sym
       entity_mapping = @mapping.get(entity_name)
       row = Row.new(row_hash, entity_mapping.fields, prefix)
-      object = @container.resolve(entity_name)
-      entity = @entity_builder.create(object)
-      entity.load_attributes!(row.attributes)
 
+      reference_hash = {}
       row.reference_names.each do |reference_name|
         if entity_mapping.references.key? reference_name.to_sym
           reference_id_name = reference_name + '__id'
           unless row_hash[reference_id_name.to_sym].nil?
             type = entity_mapping.references[reference_name.to_sym].type
-            entity.set_reference! reference_name, map(type, row_hash, session, reference_name)
+            reference_hash[reference_name.to_sym] = map(type, row_hash, session, reference_name)
           end
         end
       end
 
+      object = @container.resolve(entity_name, row.attributes_hash.merge(reference_hash))
+      entity = @entity_builder.create(object)
+      entity.load_attributes!(row.attributes)
+
+      reference_hash.each do |key, value|
+        entity.set_reference! key.to_s, value
+      end
+
       session.attach(entity)
       entity
     end

data/lib/jet_set/mixin/entity.rb

@@ -6,7 +6,7 @@ module JetSet
   module Entity
     # Loads the entity attributes.
     # Parameters:
-    #   +attributes+:: a hash of attributes in format :field => :value
+    #   +attributes+:: an array of key-pairs in format :field => :value
     def load_attributes!(attributes)
       attributes.each do |attribute|
         name = "@#{attribute[:field]}"

data/lib/jet_set/row.rb

@@ -1,7 +1,7 @@
 module JetSet
   # A container for fields/references extraction logic
   class Row
-    attr_reader :attributes, :reference_names
+    attr_reader :attributes, :attributes_hash, :reference_names
 
     def initialize(row_hash, entity_fields, prefix)
       keys = row_hash.keys.map {|key| key.to_s}
@@ -10,6 +10,11 @@ module JetSet
         .select {|key| entity_fields.include? key.sub(prefix + '__', '')}
         .map {|key| {field: key.sub(prefix + '__', ''), value: row_hash[key.to_sym]}}
 
+      @attributes_hash = {}
+      @attributes.each do |attr|
+        @attributes_hash[attr[:field].to_sym] = attr[:value]
+      end
+
       @reference_names = keys.select {|key| !key.start_with?(prefix) && key.include?('__')}
         .map {|key| key.split('__')[0]}
         .uniq

data/lib/jet_set/session.rb

@@ -14,6 +14,7 @@ module JetSet
       @query_parser = query_parser
       @entity_builder = entity_builder
       @dependency_graph = dependency_graph
+      @mutex = Mutex.new
     end
 
     # Fetches root entity using a result of +execute+ method.
@@ -87,9 +88,11 @@ module JetSet
         end
       end
 
-      to_attach.each do |object|
-        obj = object.kind_of?(Entity) ? object : @entity_builder.create(object)
-        @objects << obj
+      @mutex.synchronize do
+        to_attach.each do |object|
+          obj = object.kind_of?(Entity) ? object : @entity_builder.create(object)
+          @objects << obj
+        end
       end
     end
 

data/lib/jet_set/version.rb

@@ -1,3 +1,3 @@
 module JetSet
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jet_set
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Vladimir Kalinkin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-06 00:00:00.000000000 Z
+date: 2018-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.10.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -144,7 +144,6 @@ files:
 - lib/jet_set/row.rb
 - lib/jet_set/session.rb
 - lib/jet_set/version.rb
-- test.rb
 homepage: https://github.com/cylon-v/jet_set
 licenses:
 - MIT
@@ -166,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: JetSet is a microscopic ORM for DDD projects.

data/test.rb

@@ -1,16 +0,0 @@
-class Test
-  def initialize
-    @method = 0
-  end
-
-  def calc
-    @method = 1
-    puts @method
-  end
-end
-
-Test.define_method '@method=' do |value|
-  @method = value + 5
-end
-test = Test.new
-test.calc