jet_set 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fbe98545a86e3ed348ad663f51d537b02da5c016
+  data.tar.gz: 885290e0e7a62b94b21c78710897c722e784dd57
+SHA512:
+  metadata.gz: 5a2da70455acaf1b6e6d5cab4374b6f3a664fbb9a8b6672be44af38e1ea8889cfc26ffbf48c705fd454465095bc07a0db2cca596b1f8802999befc828fcd3173
+  data.tar.gz: 0a574a40910abb7dfef33015d11cd1c0b6b53bffe25a078c409287e7c7fd904e0d9e525cecb89682cc91b4c4f80efcf00117e6db01c6abb82cf7e3e778df82b5

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+.idea

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.15.4

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem 'hypo', path: '../hypo'
+
+gemspec
+
+

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Vladimir Kalinkin
+
+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/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Vladimir Kalinkin
+
+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,39 @@
+# JetSet
+
+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
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jet_set'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jet_set
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/jet_set.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "jet_set"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/jet_set.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jet_set/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'jet_set'
+  spec.version       = JetSet::VERSION
+  spec.authors       = ['Vladimir Kalinkin']
+  spec.email         = ['vova.kalinkin@gmail.com']
+
+  spec.summary       = 'JetSet is a microscopic ORM for DDD projects.'
+  spec.description   = ''
+  spec.homepage      = 'https://github.com/cylon-v/jet_set'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'sequel', '~> 5.4.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'sqlite3', '~> 1.3'
+  spec.add_development_dependency 'simplecov', '~> 0.16'
+end

data/lib/jet_set.rb

@@ -0,0 +1,13 @@
+require 'hypo'
+require 'sequel'
+require 'sequel/extensions/inflector'
+require 'jet_set/environment'
+require 'jet_set/mapping'
+require 'jet_set/version'
+
+module JetSet
+  Sequel.extension :inflector
+  include JetSet::Environment
+
+  module_function :init, :open_session, :register_session, :map
+end

data/lib/jet_set/attribute.rb

@@ -0,0 +1,19 @@
+module JetSet
+  # A structure for tracking an entity attribute state.
+  class Attribute
+    attr_reader :name, :value
+
+    # Initializes the attribute state
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    # Returns +true+ if the attribute is changed and +false+ if it's not.
+    # Parameters:
+    #   +value+:: current value to compare.
+    def changed?(value)
+      @value != value
+    end
+  end
+end

data/lib/jet_set/collection.rb

@@ -0,0 +1,17 @@
+module JetSet
+  # Collection represents a collection attribute mapping.
+  # Should be instantiated by method +collection+ of +JetSet::EntityMapping+ instance.
+  class Collection
+    attr_reader :name, :type, :using
+
+    # Parameters:
+    #   +name+:: name of the attribute
+    #   +type+:: class of an entity
+    #   +using+:: (optional) name of many-to-many association table if needed.
+    def initialize(name, type, using = nil)
+      @name = name
+      @type = type
+      @using = using
+    end
+  end
+end

data/lib/jet_set/dependency_graph.rb

@@ -0,0 +1,32 @@
+module JetSet
+  # Dependency graph stores a matrix of entities dependencies and is used by +JetSet::Session+
+  # for ordering entities for persistence process using method +order+.
+  class DependencyGraph
+    # Initializes a dependency graph using a mapping definition.
+    # Parameters:
+    #   +mapping+:: JetSet::Mapping
+    def initialize(mapping)
+      @matrix = {}
+
+      mapping.entity_mappings.keys.each do |key|
+        entity = mapping.entity_mappings[key]
+        @matrix[entity.type.name] = entity.dependencies.map{|d| d.name}
+      end
+    end
+
+    # Orders entities according their dependencies in mapping definition.
+    # Parameters:
+    #   +entities+:: entities to order.
+    def order(entities)
+      groups = {}
+      entities.each do |entity|
+        groups[entity.class.name] ||= []
+        groups[entity.class.name] << entity
+      end
+
+      type_order = groups.keys.sort{|a, b| @matrix[b].include?(a) ? -1 : 1}
+      entity_order = type_order.map{|type| groups[type]}
+      entity_order.flatten
+    end
+  end
+end

data/lib/jet_set/entity_builder.rb

@@ -0,0 +1,27 @@
+require 'jet_set/mixin/identity'
+require 'jet_set/mixin/entity'
+
+module JetSet
+  # A converter of a pure Ruby object to JetSet trackable object.
+  class EntityBuilder
+
+    # Parameters:
+    #   +mapping+:: an instance of +JetSet::Mapping+
+    def initialize(mapping)
+      @mapping = mapping
+    end
+
+    # Makes passed object to be trackable.
+    # +object+:: pure Ruby object
+    def create(object)
+      object.instance_variable_set('@__attributes', {})
+      object.instance_variable_set('@__references', {})
+      object.instance_variable_set('@__collections', {})
+      object.instance_variable_set('@__mapping', @mapping)
+      object.instance_variable_set('@__factory', self)
+
+      object.extend(Identity)
+      object.extend(Entity)
+    end
+  end
+end

data/lib/jet_set/entity_mapping.rb

@@ -0,0 +1,63 @@
+require 'jet_set/reference'
+require 'jet_set/collection'
+
+module JetSet
+  # Entity mapping is an element of JetSet mapping definition, see +JetSet::Mapping+.
+  # Should be instantiated by method +entity+ of +JetSet::Mapping+ instance.
+  class EntityMapping
+    attr_reader :references, :collections, :fields, :type, :dependencies
+
+    # Initializes the mapping using Ruby block.
+    # Parameters:
+    #   +type+:: an entity class
+    #   +&block+:: should contain attributes definitions see methods +field+, +collection+, +reference+.
+    def initialize(type, &block)
+      @type = type
+      @references = {}
+      @collections = {}
+      @dependencies = []
+      @fields = ['id']
+
+      if block_given?
+        instance_eval(&block)
+      end
+    end
+
+    # Defines an attribute of a simple type (String, Integer, etc)
+    # Parameters:
+    #   +name+:: attribute name
+    def field(name)
+      @fields << name.to_s
+    end
+
+    # Defines an attribute of a complex type - another entity defined in the mapping.
+    # Parameters:
+    #   +name+:: attribute name
+    #   +params+::
+    #     +type+:: class of the entity
+    #     +weak+:: (optional) a flag for making a reference to an entity which is not directly
+    #              associated for skipping persistence steps for it
+    def reference(name, params = {})
+      unless params.has_key? :type
+        raise MapperError, "Reference \"#{name}\" should have a type. Example:\n reference '#{name}', type: User\n"
+      end
+
+      @references[name] = Reference.new(name, params[:type])
+      @dependencies << params[:type] unless params[:weak]
+    end
+
+    # Defines an attribute-collection of a complex type - another entity defined in the mapping.
+    # Parameters:
+    #   +name+:: attribute name
+    #   +params+::
+    #     +type+:: class of the entity
+    #     +using+:: (optional) a name of many-to-many association table if needed.
+    def collection(name, params = {})
+      unless params.has_key? :type
+        raise MapperError, "Collection \"#{name}\" should have a type. Example:\n collection '#{name}', type: User\n"
+      end
+
+      @collections[name] = Collection.new(name, params[:type], params[:using])
+    end
+  end
+end

data/lib/jet_set/environment.rb

@@ -0,0 +1,91 @@
+require 'hypo'
+require 'sequel'
+require 'jet_set/entity_builder'
+require 'jet_set/session'
+require 'jet_set/mapping'
+require 'jet_set/mapper'
+require 'jet_set/entity_mapping'
+require 'jet_set/query_parser'
+require 'jet_set/dependency_graph'
+
+module JetSet
+  module Environment
+    # Initializes JetSet environment.
+    # Parameters:
+    # +mapping+:: JetSet mapping definition. Instance of JetSet::Mapping class.
+    # +container+:: (optional) Existing Hypo::Container instance.
+    def init(mapping, container = Hypo::Container.new)
+      @container = container
+
+      @container.register_instance(mapping, :mapping)
+
+      @container.register(JetSet::EntityBuilder, :entity_builder)
+        .using_lifetime(:singleton)
+
+      @container.register(JetSet::Mapper, :mapper)
+        .using_lifetime(:singleton)
+
+      @container.register(JetSet::QueryParser, :query_parser)
+        .using_lifetime(:singleton)
+    end
+
+    # Creates JetSet session and registers it in Hypo container.
+    # Parameters:
+    # +scope+:: a name of registered component which manages the session lifetime.
+    def register_session(scope = nil)
+      session_component = @container.register(JetSet::Session, :session)
+      dependency_graph_component = @container.register(JetSet::DependencyGraph, :dependency_graph)
+
+      if scope.nil?
+        @container.register_instance(nil, :session_scope)
+        session_component.use_lifetime(:transient)
+        dependency_graph_component.use_lifetime(:transient)
+      else
+        @container.register_instance(scope, :session_scope)
+        session_component.use_lifetime(:scope).bind_to(scope)
+        dependency_graph_component.use_lifetime(:scope).bind_to(scope)
+      end
+
+    end
+
+    # Creates JetSet session and registers it in Hypo container.
+    # Parameters:
+    # +connection+:: Sequel connection.
+    # +scope+:: a name of registered component which manages the session lifetime.
+    # Returns the session object.
+    def open_session(connection, scope = nil)
+      @container.register_instance(connection, :connection)
+
+      register_session(scope)
+      @container.resolve(:session)
+    end
+
+
+    # Accepts Ruby block with mapping definition.
+    # Parameters:
+    #   +&block+: Ruby block
+    # Usage:
+    #   JetSet::Mapping.new do
+    #     entity Invoice do
+    #       field :amount
+    #       field :created_at
+    #       collection :line_items
+    #       reference :subscription, type: Subscription
+    #     end
+    #     ...
+    #     entity User do
+    #       field :amount
+    #       field :created_at
+    #       collection :line_items
+    #       reference :subscription, type: Subscription
+    #     end
+    #   end
+    def map(&block)
+      unless block_given?
+        raise MapperError, 'Mapping should be defined as Ruby block.'
+      end
+
+      Mapping.new(&block)
+    end
+  end
+end

data/lib/jet_set/mapper.rb

@@ -0,0 +1,119 @@
+require 'sequel'
+require 'jet_set/mapper_error'
+require 'jet_set/row'
+
+module JetSet
+  # A converter of a data rows to object model according to a mapping.
+  class Mapper
+    # Parameters:
+    #   +entity_builder+:: an instance of +JetSet::EntityBuilder+
+    #   +mapping+:: an instance of +JetSet::Mapping+
+    #   +container+:: IoC container (+Hypo::Container+) for resolving entity dependencies
+    def initialize(entity_builder, mapping, container)
+      @entity_builder = entity_builder
+      @mapping = mapping
+      @container = container
+
+      @mapping.entity_mappings.values.each do |entity_mapping|
+        container.register(entity_mapping.type)
+      end
+    end
+
+    # Converts a table row to an object
+    # Parameters:
+    #   +type+:: entity type defined in the mapping
+    #   +row_hash+:: hash representation of table row
+    #   +session+:: instance of +JetSet::Session+
+    #   +prefix+:: (optional) custom prefix for extracting the type attributes,
+    #     i.e."customer" for query:
+    #       "SELECT u.name AS customer__name from users u"
+    def map(type, row_hash, session, prefix = type.name.underscore)
+      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)
+
+      row.reference_names.each do |reference_name|
+        if entity_mapping.references.key? reference_name.to_sym
+          type = entity_mapping.references[reference_name.to_sym].type
+          entity.set_reference! reference_name, map(type, row_hash, session, reference_name)
+        end
+      end
+
+      session.attach(entity)
+      entity
+    end
+
+    # Constructs object model relationships between of complex objects.
+    # Parameters:
+    #   +target+:: an instance or an array of entity instances
+    #   +name+:: name of the target attribute to bind
+    #   +rows+:: an array of database rows (hashes)
+    #   +session+:: an instance of +JetSet::Session+
+    def map_association(target, name, rows, session)
+      singular_name = name.to_s.singularize.to_sym
+      entity_mapping = @mapping.get(singular_name)
+
+      if target.is_a? Array
+        relations = {}
+        target_name = target[0].class.name.underscore
+        back_relations = {}
+
+        if rows.length > 0
+          target_id_name = "#{target_name.underscore}_id"
+          target_reference = entity_mapping.references[target_name.to_sym]
+
+          rows.each do |row|
+            relation = map(entity_mapping.type, row, session, singular_name.to_s)
+            target_id = row[target_id_name.to_sym]
+
+            if target_id.nil?
+              raise MapperError, "Field \"#{target_id_name}\" is not defined in the query but it's required to construct \"#{name} to #{target_name}\" association. Just add it to SELECT clause."
+            end
+
+            relations[target_id] ||= []
+            relations[target_id] << relation
+            back_relations[relation.id] = target.select{|t| t.id == target_id}
+          end
+
+          target.each do |entry|
+            target_id = entry.id
+            relation_objects = relations[target_id]
+
+            if relation_objects
+              if target_reference
+                relation_objects.each {|obj| obj.set_reference!(target_reference.name, entry)}
+              end
+
+              # set forward collection relation
+              entry.set_collection!(name, relations[target_id])
+
+              # set reverse collection relation if it's present
+              if entity_mapping.collections[target_name.pluralize.to_sym]
+                relation_objects.each{|obj| obj.set_collection!(target_name.pluralize.to_sym, back_relations[obj.id])}
+              end
+            end
+          end
+        end
+
+        ids = []
+        relations.values.each do |associations|
+          ids << associations.map{|a| a.id}
+        end
+
+        {result: relations, ids: ids.flatten.uniq}
+      else
+        result = rows.map do |row|
+          map(entity_mapping.type, row, session, singular_name.to_s)
+        end
+
+        target.set_collection!(name, result)
+
+        {result: result, ids: result.map {|i| i.id}}
+      end
+
+    end
+  end
+end

data/lib/jet_set/mapper_error.rb

@@ -0,0 +1,5 @@
+module JetSet
+  # A common error for handling an unexpected states.
+  class MapperError < StandardError
+  end
+end

data/lib/jet_set/mapping.rb

@@ -0,0 +1,41 @@
+require 'jet_set/entity_mapping'
+
+module JetSet
+  # Represents JetSet Mapping.
+  class Mapping
+    attr_reader :entity_mappings
+
+    # Initializes the mapping using Ruby block.
+    # Parameters:
+    #   +&block+:: should contain "entity" definitions see method +entity+.
+    def initialize(&block)
+      @entity_mappings = {}
+      instance_eval(&block)
+    end
+
+    # Defines an entity mapping
+    # Parameters:
+    #   +type+:: an entity class
+    #   +&block+:: should contain mapping definitions of the entity attributes. See +JetSet::EntityMapping+ class.
+    # Returns an instance of +EntityMapping+
+    def entity(type, &block)
+      unless type.is_a? Class
+        raise MapperError, 'Mapping definition of an entity should begin from a type declaration which should be a Class.'
+      end
+
+      name = type.name.underscore.to_sym
+      if @entity_mappings.has_key?(name)
+        raise MapperError, "Mapping definition for entity of type #{type} is already registered."
+      end
+
+      @entity_mappings[name] = EntityMapping.new(type, &block)
+    end
+
+    # Returns an entity mapping by its +name+.
+    # Parameters:
+    #   +name+:: string
+    def get(name)
+      @entity_mappings[name]
+    end
+  end
+end

data/lib/jet_set/mixin/entity.rb

@@ -0,0 +1,174 @@
+require 'jet_set/attribute'
+
+module JetSet
+  # A decorator for domain objects.
+  # It adds JetSet specific stuff for object changes tracking and persistence.
+  module Entity
+    # Loads the entity attributes.
+    # Parameters:
+    #   +attributes+:: a hash of attributes in format :field => :value
+    def load_attributes!(attributes)
+      attributes.each do |attribute|
+        name = "@#{attribute[:field]}"
+        value = attribute[:value]
+        instance_variable_set(name, value)
+        @__attributes[name] = Attribute.new(name, value)
+      end
+    end
+
+    # Sets a reference to another entity.
+    # Parameters:
+    #   +name+:: name of an entity defined in the mapping
+    #   +value+:: an instance of an entity
+    def set_reference!(name, value)
+      @__references[name] = value
+      instance_variable_set("@#{name}", value)
+    end
+
+    # Sets a collection of related entities.
+    # Parameters:
+    #   +name+:: name of an entity defined in the mapping
+    #   +value+:: an array of instances of the entity
+    def set_collection!(name, value)
+      @__collections[name] = value.map{|item| item.respond_to?(:id) ? item.id : nil}.select{|item| !item.nil?}
+      instance_variable_set("@#{name}", value)
+    end
+
+    # Returns +true+ if entity is not loaded from the database and +false+ if it is.
+    def new?
+      @id.nil?
+    end
+
+    # Returns +true+ if the entity contains unsaved changes (attributes, references, collection)
+    # or if it's new (see +new?+ method).
+    def dirty?
+      attributes_changed = @__attributes.keys.any? do |name|
+        attribute = @__attributes[name]
+        current_value = instance_variable_get(attribute.name)
+        attribute.changed?(current_value)
+      end
+
+      collections_changed = @__collections.keys.any? do |name|
+        initial_state = @__collections[name]
+        current_state = instance_variable_get("@#{name}").map{|item| item.id}.select{|id| !id.nil?}
+        to_delete = initial_state - current_state
+        to_insert = current_state.select {|item| !item.respond_to?(:id)}
+        to_insert.length > 0 || to_delete.length > 0
+      end
+
+      references_changed = @__references.keys.any? do |name|
+        initial_state = @__references[name]
+        current_state = instance_variable_get("@#{name}")
+        current_state != initial_state
+      end
+
+      attributes_changed || references_changed || collections_changed || new?
+    end
+
+    # Enumerates changed attributes
+    def dirty_attributes
+      @__attributes.keys.select {|name|
+        current_value = instance_variable_get(name)
+        @__attributes[name].changed?(current_value)
+      }.map {|name| @__attributes[name]}
+    end
+
+    # Flushes current state and saves a changes to the database.
+    # Parameters:
+    #   +connection+:: Sequel connection
+    def flush(connection)
+      table_name = self.class.name.underscore.pluralize.to_sym
+      table = connection[table_name]
+      entity_name = self.class.name.underscore.to_sym
+      my_column_name = self.class.name.underscore + '_id'
+
+      entity = @__mapping.get(entity_name)
+
+      if new?
+        attributes = []
+        entity.fields.each do |field|
+          attributes << {field: field, value: instance_variable_get("@#{field}")}
+        end
+
+        load_attributes!(attributes)
+
+        fields = @__attributes.keys.map {|name| name.sub('@', '')}.select {|a| a != 'id'}
+        values = @__attributes.keys.select {|name| name.sub('@', '') != 'id'}.map {|name| @__attributes[name].value}
+
+        entity.references.keys.each do |key|
+          value = instance_variable_get("@#{key}")
+          if value
+            reference_id = value.instance_variable_get('@id')
+            if reference_id.nil?
+              @__factory.create(value)
+              value.flush(connection)
+            end
+            set_reference!(key, value)
+            fields << "#{key}_id"
+
+            values << value.instance_variable_get('@id')
+          end
+        end
+        new_id = table.insert(fields, values)
+        @__attributes['@id'] = Attribute.new('@id', new_id)
+        @id = new_id
+      elsif dirty?
+        attributes = {}
+        dirty_attributes.each {|attribute| attributes[attribute.name.sub('@', '')] = instance_variable_get(attribute.name)}
+        if attributes.keys.length > 0
+          table.where(id: @id).update(attributes)
+        end
+      end
+
+      # synchronize collections
+      entity.collections.keys.each do |key|
+        unless @__collections.key? key
+          set_collection!(key, instance_variable_get("@#{key}"))
+        end
+      end
+
+      @__collections.keys.each do |name|
+        initial_state = @__collections[name]
+        current_state = instance_variable_get("@#{name}")
+
+        to_delete = initial_state.select{|item| !item.nil?} - current_state.select{|item| item.respond_to?(:id)}.map{|item| item.id}
+        to_insert = current_state.select{|item| !item.respond_to?(:id)}
+
+        if to_delete.length > 0
+          if entity.collections[name].using
+            foreign_column_name = name.to_s.singularize.underscore + '_id'
+            to_delete.each do |foreign_id|
+              connection[entity.collections[name].using.to_sym].where(my_column_name => id, foreign_column_name => foreign_id).delete
+            end
+          else
+            connection[name].where(id: to_delete).delete
+          end
+        end
+
+        to_insert.each do |item|
+          @__factory.create(item)
+          item.flush(connection)
+        end
+
+        if entity.collections[name].using
+          to_association_insert = []
+          current_state.each do |current_item|
+            to_association_insert << current_item unless initial_state.any?{|item| item == current_item}
+          end
+
+          relation_table = entity.collections[name].using.to_sym
+
+          to_association_insert.each do |item|
+            unless item.id
+              @__factory.create(item)
+              item.flush(connection)
+            end
+
+            foreign_column_name = item.class.name.underscore + '_id'
+            connection[relation_table].insert([my_column_name, foreign_column_name], [@id, item.id])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jet_set/mixin/identity.rb

@@ -0,0 +1,14 @@
+module JetSet
+  # Identity decorator. Adds identifier to pure Ruby objects.
+  module Identity
+    # Compares the object with another object using their types and IDs.
+    def ==(object)
+      self.class == object.class && @id == object.id
+    end
+
+    # Object identifier
+    def id
+      @id
+    end
+  end
+end

data/lib/jet_set/query.rb

@@ -0,0 +1,27 @@
+module JetSet
+  # Parsed JetSet query
+  class Query
+    attr_reader :sql
+
+    # Parameters:
+    #   attrs:
+    #     sql: parsed valid SQL expression
+    #     returns_single_item: does SQL expression return single row? (LIMIT 1)
+    #     entities: entities (+JetSet:EntityMapping+) enumerated in the query statements
+    def initialize(attrs = {})
+      @sql = attrs[:sql]
+      @returns_single_item = attrs[:returns_single_item] || false
+      @entities = attrs[:entities] || []
+    end
+
+    # Does SQL expression return single row? (LIMIT 1)
+    def returns_single_item?
+      @returns_single_item
+    end
+
+    # Is entity type enumerated in ENTITY statements?
+    def refers_to?(type)
+      @entities.any?{|entity| entity.type == type}
+    end
+  end
+end

data/lib/jet_set/query_parser.rb

@@ -0,0 +1,46 @@
+require 'jet_set/query'
+
+module JetSet
+  # A converter of JetSet syntax to SQL queries.
+  class QueryParser
+    # Initializes the parser
+    # Parameters:
+    #   +mapping+:: JetSet mapping +JetSet:Mapping+.
+    def initialize(mapping)
+      @mapping = mapping
+    end
+
+    # Parses JetSet query and returns SQL query.
+    # Parameters:
+    #   +expression+:: an SQL query with trivial extensions
+    def parse(expression)
+      sql = expression.dup
+
+      returns_single_item = sql.scan(/LIMIT 1(\\n|;|\s)*\z/i).any?
+      entity_matches = sql.scan(/(\s*)(\w+)\.\*\s+AS\s+ENTITY\s+(\w+)/i)
+      entity_expressions = sql.scan(/(\w+\.\*\s+AS\s+ENTITY\s+\w+)/i).flatten
+
+      entities = []
+      entity_matches.each_with_index do |match, index|
+        spaces_str = match[0]
+        alias_name = match[1]
+        entity_name = match[2]
+        entity = @mapping.get(entity_name.to_sym)
+
+        if entity.nil?
+          raise MapperError, "Entity \"#{entity_name}\" is not defined in the mapping. Query:\n#{expression}"
+        end
+
+        entities << entity
+        fields_sql = entity.fields.map {|field| "#{alias_name}.#{field} AS #{entity_name}__#{field}"}.join(",#{spaces_str}")
+        sql.sub!(entity_expressions[index], fields_sql)
+      end
+
+      Query.new({
+        sql: sql,
+        returns_single_item: returns_single_item,
+        entities: entities
+      })
+    end
+  end
+end

data/lib/jet_set/reference.rb

@@ -0,0 +1,15 @@
+module JetSet
+  # Reference represents a mapping of complex type attribute (another entity).
+  # Should be instantiated by method +reference+ of +JetSet::EntityMapping+ instance.
+  class Reference
+    attr_reader :name, :type
+
+    # Parameters:
+    #   +name+:: name of the attribute
+    #   +type+:: class of an entity
+    def initialize(name, type)
+      @name = name
+      @type = type
+    end
+  end
+end

data/lib/jet_set/row.rb

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

data/lib/jet_set/session.rb

@@ -0,0 +1,110 @@
+require 'sequel'
+
+module JetSet
+  class Session
+    # Initializes +Session+ object.
+    # Parameters:
+    # +connection+:: Sequel connection object.
+    # +mapper+:: Sequel rows to Ruby objects mapper.
+    # +query_parser+:: a parser which evaluates JetSet extensions in SQL-expressions.
+    def initialize(connection, mapper, query_parser, entity_builder, dependency_graph)
+      @connection = connection
+      @mapper = mapper
+      @objects = []
+      @query_parser = query_parser
+      @entity_builder = entity_builder
+      @dependency_graph = dependency_graph
+    end
+
+    # Fetches root entity using a result of +execute+ method.
+    # Parameters:
+    # +type+:: Ruby class of an object to map.
+    # +expression+:: SQL-like query
+    # +params+:: +query+ params
+    # +&block+:: further handling of the result.
+    def fetch(type, expression, params = {}, &block)
+      unless type.is_a? Class
+        raise MapperError, 'Parameter "type" should be a Class.'
+      end
+
+      query = @query_parser.parse(expression)
+      unless query.refers_to?(type)
+        raise MapperError, "The query doesn't contain \"AS ENTITY #{type.name.underscore}\" statement."
+      end
+
+      rows = @connection.fetch(query.sql, params).to_a
+      if rows.length == 0
+        result = nil
+      elsif rows.length == 1 && query.returns_single_item?
+        result = @mapper.map(type, rows[0], self)
+      else
+        if query.returns_single_item?
+          raise MapperError, "A single row was expected to map but the query returned #{rows.length} rows."
+        end
+
+        result = []
+        rows.each do |row|
+          result << @mapper.map(type, row, self)
+        end
+      end
+
+      if block_given?
+        instance_exec(result, &block)
+      end
+
+      result
+    end
+
+    # Loads nested references and collections using sub-query
+    # for previously loaded aggregation root, see +map+ method.
+    # Parameters:
+    # +target+:: single or multiple entities that are a Ruby objects constructed by +map+ or +preload+ method.
+    # +relation+:: an object reference or collection name defined in JetSet mapping for the +target+.
+    def preload(target, relation, query, params = {}, &block)
+      query = @query_parser.parse(query)
+      rows = @connection.fetch(query.sql, params).to_a
+      result = @mapper.map_association(target, relation, rows, self)
+
+      if block_given?
+        instance_exec(result[:result], result[:ids], &block)
+      end
+    end
+
+    # Makes an object to be tracked by the session.
+    # Since this moment all related to object changes will be saved on session finalization.
+    # Use this method for newly created aggregation roots. No need to use it for new objects
+    # that were bound to a root which is already attached. All objects loaded from the database
+    # are already under the session tracking.
+    # Parameters:
+    # +objects+:: any Ruby objects defined in the mapping.
+    def attach(*objects)
+      to_attach = []
+      objects.each do |object|
+        if object.is_a? Array
+          object.each{|o| to_attach << o}
+        else
+          to_attach << object
+        end
+      end
+
+      to_attach.each do |object|
+        obj = object.kind_of?(Entity) ? object : @entity_builder.create(object)
+        @objects << obj
+      end
+    end
+
+    # Saves all changes of attached objects to the database.
+    # * Compatible with +Hypo::Scope+ +finalize+ interface,
+    # see Hypo docs at https://github.com/cylon-v/hypo.
+    def finalize
+      dirty_objects = @objects.select {|object| object.dirty?}
+      ordered_objects = @dependency_graph.order(dirty_objects)
+
+      if ordered_objects.length > 0
+        @connection.transaction do
+          ordered_objects.each{|obj| obj.flush(@connection)}
+        end
+      end
+    end
+  end
+end

data/lib/jet_set/version.rb

@@ -0,0 +1,3 @@
+module JetSet
+  VERSION = "0.2.0"
+end

data/test.rb

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

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: jet_set
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Vladimir Kalinkin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.4.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+description: ''
+email:
+- vova.kalinkin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- jet_set.gemspec
+- lib/jet_set.rb
+- lib/jet_set/attribute.rb
+- lib/jet_set/collection.rb
+- lib/jet_set/dependency_graph.rb
+- lib/jet_set/entity_builder.rb
+- lib/jet_set/entity_mapping.rb
+- lib/jet_set/environment.rb
+- lib/jet_set/mapper.rb
+- lib/jet_set/mapper_error.rb
+- lib/jet_set/mapping.rb
+- lib/jet_set/mixin/entity.rb
+- lib/jet_set/mixin/identity.rb
+- lib/jet_set/query.rb
+- lib/jet_set/query_parser.rb
+- lib/jet_set/reference.rb
+- 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
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: JetSet is a microscopic ORM for DDD projects.
+test_files: []