rom-session 0.1.0

data/lib/rom/session/tracker.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+
+    # @api private
+    class Tracker
+      attr_reader :objects, :changelog
+      private :objects, :changelog
+
+      # @api private
+      def initialize
+        @objects   = {}
+        @changelog = []
+      end
+
+      # @api private
+      def commit
+        @changelog.each { |state| update(state.commit) }
+        @changelog = []
+      end
+
+      # @api private
+      def fetch(object)
+        @objects.fetch(object.__id__) { raise ObjectNotTrackedError, object }
+      end
+
+      # @api private
+      def include?(object)
+        @objects.key?(object.__id__)
+      end
+
+      # @api private
+      def clean?
+        changelog.empty?
+      end
+
+      # @api private
+      def queue(state)
+        @changelog << state
+        update(state)
+      end
+
+      # @api private
+      def update(state)
+        store(state.object, state)
+      end
+
+      # @api private
+      def store_transient(object, mapper)
+        store(object, State::Transient.new(object, mapper))
+      end
+
+      # @api private
+      def store_persisted(object, mapper)
+        store(object, State::Persisted.new(object, mapper))
+      end
+
+      private
+
+      # @api private
+      def store(object, state)
+        @objects[object.__id__] = state
+      end
+
+    end # Tracker
+
+  end # Session
+end # ROM

data/lib/rom/session/version.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+
+    VERSION = '0.1.0'.freeze
+
+  end # Session
+end # ROM

data/lib/rom/support/proxy.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module ROM
+
+  module Proxy
+
+    def self.included(descendant)
+      descendant.send :undef_method, *descendant.superclass.public_instance_methods(false).map(&:to_s)
+      descendant.extend(Constructor)
+      super
+    end
+
+    module Constructor
+
+      def new(*args)
+        proxy = super(*args)
+        decorated_object = args.first
+        proxy.instance_variable_set '@__decorated_class', decorated_object.class
+        proxy.instance_variable_set '@__decorated_object', decorated_object
+        proxy.instance_variable_set '@__args', args[1..args.size]
+        proxy
+      end
+
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      forwardable?(method) ? forward(method, *args, &block) : super
+    end
+
+    def forwardable?(method)
+      @__decorated_object.respond_to?(method)
+    end
+
+    def forward(*args, &block)
+      response = @__decorated_object.public_send(*args, &block)
+
+      if response.equal?(@__decorated_object)
+        self
+      elsif response.kind_of?(@__decorated_class)
+        self.class.new(response, *@__args)
+      else
+        response
+      end
+    end
+
+  end # Proxy
+
+end # ROM

data/rom-session.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/rom/session/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'rom-session'
+  gem.description = 'Session for ROM'
+  gem.summary     = gem.description
+  gem.authors     = ['Markus Schirp', 'Piotr Solnica']
+  gem.email       = ['mbj@schirp-dso.com', 'piotr.solnica@gmail.com']
+  gem.version     = ROM::Session::VERSION.dup
+  gem.homepage    = 'http://rom-rb.org'
+
+  gem.files            = `git ls-files`.split("\n")
+  gem.test_files       = `git ls-files -- {spec,features}/*`.split("\n")
+  gem.require_paths    = %w(lib)
+  gem.extra_rdoc_files = %w(README.md LICENSE)
+  gem.license          = 'MIT'
+
+  gem.add_dependency('adamantium',    '~> 0.1')
+  gem.add_dependency('equalizer',     '~> 0.0.7')
+  gem.add_dependency('abstract_type', '~> 0.0.6')
+  gem.add_dependency('concord',       '~> 0.1.4')
+end

data/spec/integration/session_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Session' do
+  let(:users)    { TEST_ENV.schema[:users] }
+  let(:relation) { TEST_ENV[:users] }
+  let(:mapper)   { relation.mapper }
+  let(:model)    { mapper.loader.model }
+
+  before do
+    users.insert([[1, 'John'], [2, 'Jane']])
+  end
+
+  after do
+    users.delete([[1, 'John'], [2, 'Jane'], [3, 'Piotr']])
+  end
+
+  specify 'fetching an object from a relation' do
+    Session.start(users: relation) do |session|
+      # fetch user for the first time
+      jane1 = session[:users].restrict(name: 'Jane').one
+
+      expect(jane1).to eq(model.new(id: 2, name: 'Jane'))
+
+      # here IM-powered loader kicks in
+      jane2 = session[:users].restrict(name: 'Jane').one
+
+      expect(jane1).to be(jane2)
+    end
+  end
+
+  specify 'deleting an object from a relation' do
+    Session.start(users: relation) do |session|
+      jane = session[:users].restrict(name: 'Jane').one
+
+      session[:users].delete(jane)
+
+      session.flush
+
+      expect(relation.to_a).not_to include(jane)
+    end
+  end
+
+  specify 'saving an object to a relation' do
+    Session.start(users: relation) do |session|
+      piotr = session[:users].new(id: 3, name: 'Piotr')
+
+      session[:users].save(piotr)
+
+      session.flush
+
+      expect(relation.to_a).to include(piotr)
+    end
+  end
+
+  specify 'updating an object in a relation' do
+    Session.start(users: relation) do |session|
+      jane = session[:users].restrict(id: 2).one
+      jane.name = 'Jane Doe'
+
+      session[:users].save(jane)
+
+      session.flush
+
+      expect(relation.count).to be(2)
+
+      expect(relation.to_a.last).to eql(jane)
+    end
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

data/spec/shared/unit/environment_context.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+shared_context 'Session::Environment' do
+  let(:object) { described_class.new({ users: users }, Session::Tracker.new) }
+
+  let(:users) {
+    relation = TEST_ENV.repository(:test)[:users]
+    mapper   = Mapper.build(relation.header, mock_model(:id, :name))
+    Relation.new(relation, mapper)
+  }
+end

data/spec/shared/unit/relation_context.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+shared_context 'Session::Relation' do
+  let(:users)    { session[:users] }
+  let(:object)   { users }
+
+  let(:session)  { Session.new(env) }
+  let(:env)      { Session::Environment.new({ users: relation }, tracker) }
+  let(:tracker)  { Session::Tracker.new }
+
+  let(:mapper)   { Mapper.build([[:id, Integer], [:name, String]], model, keys: [:id]) }
+  let(:model)    { mock_model(:id, :name) }
+  let(:header)   { TEST_ENV.schema[:users].header }
+  let(:axiom)    { Axiom::Relation::Variable.new(Axiom::Relation.new(header, [[1, 'John'], [2, 'Jane']])) }
+  let(:relation) { Relation.new(axiom, mapper) }
+
+  let(:user) { session[:users].to_a.first }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name 'spec:unit'
+
+    add_filter 'config'
+    add_filter 'lib/rom/support'
+    add_filter 'spec'
+  end
+end
+
+class BasicObject
+  def self.freeze
+    # FIXME: remove this when axiom no longer freezes classes
+  end
+end
+
+require 'devtools/spec_helper'
+
+require 'rom-session'
+
+require 'axiom'
+require 'rom-relation'
+require 'rom-mapper'
+require 'rom/support/axiom/adapter/memory'
+
+require 'bogus/rspec'
+
+include ROM
+
+def mock_model(*attributes)
+  Class.new {
+    include Equalizer.new(*attributes)
+
+    attributes.each { |attribute| attr_accessor attribute }
+
+    def initialize(attrs = {})
+      attrs.each { |name, value| send("#{name}=", value) }
+    end
+  }
+end
+
+TEST_ENV = Environment.setup(test: 'memory://test')
+
+TEST_ENV.schema do
+  base_relation :users do
+    repository :test
+
+    attribute :id,   Integer
+    attribute :name, String
+
+    key :id
+  end
+end
+
+TEST_ENV.mapping do
+  users do
+    model mock_model(:id, :name)
+    map :id, :name
+  end
+end

data/spec/unit/rom/session/class_methods/start_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Session, '.start' do
+  include_context 'Session::Relation'
+
+  let(:user) { model.new(id: 3, name: 'Piotr') }
+
+  it 'starts a new session' do
+    Session.start(users: relation) do |session|
+      expect(session).to be_clean
+      expect(session).to be_instance_of(Session)
+      expect(session[:users]).to be_instance_of(Session::Relation)
+
+      session[:users].track(user).save(user)
+
+      session.flush
+    end
+
+    expect(relation.to_a).to include(user)
+  end
+end

data/spec/unit/rom/session/clean_predicate_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Session, '#clean?' do
+  subject { session.clean? }
+
+  include_context 'Session::Relation'
+
+  context 'when tracker has no pending state changes' do
+    it { should be_true }
+  end
+
+  context 'when tracker has pending state changes' do
+    before do
+      session[:users].delete(user)
+    end
+
+    it { should be_false }
+  end
+end

data/spec/unit/rom/session/environment/element_reader_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Session::Environment, '#[]' do
+  subject { object[:users] }
+
+  include_context 'Session::Environment'
+
+  it 'returns session relation proxy' do
+    expect(subject).to be_kind_of(Session::Relation)
+  end
+end

data/spec/unit/rom/session/flush_spec.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Session, '#flush' do
+  subject { session.flush }
+
+  include_context 'Session::Relation'
+
+  let(:object) { session }
+
+  let(:john)  { session[:users].to_a.first }
+  let(:jane)  { session[:users].to_a.last }
+  let(:piotr) { session[:users].new(id: 3, name: 'Piotr') }
+
+  before do
+    session[:users].delete(john)
+
+    jane.name = 'Jane Doe'
+    session[:users].save(jane)
+
+    session[:users].save(piotr)
+  end
+
+  it_behaves_like 'a command method'
+
+  it { should be_clean }
+
+  it 'commits all deletes' do
+    expect(subject[:users].to_a).to_not include(john)
+  end
+
+  it 'commits all updates' do
+    expect(subject[:users].to_a.first).to eq(relation.to_a.first)
+  end
+
+  it 'commits all inserts' do
+    expect(subject[:users].to_a).to include(piotr)
+  end
+
+  it 'sets correct state for created objects' do
+    expect(subject[:users].state(piotr)).to be_persisted
+    expect(subject[:users].dirty?(piotr)).to be(false)
+  end
+
+  it 'registers newly created object in the IM' do
+    expect(subject[:users].restrict { |r| r.name.eq('Piotr') }.to_a.first).to be(piotr)
+  end
+
+  it 'sets correct state for updated objects' do
+    expect(subject[:users].state(jane)).to be_persisted
+  end
+
+  it 'sets correct state for deleted objects' do
+    expect(subject[:users].state(john)).to be_frozen
+  end
+
+end