rom 0.1.2 → 0.2.0

data/spec/integration/session_spec.rb

@@ -0,0 +1,87 @@
+# 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.model }
+
+  before do
+    users.insert([[1, 'John'], [2, 'Jane']])
+  end
+
+  after do
+    users.delete([[1, 'John'], [2, 'Jane'], [2, 'Jane Doe'], [3, 'Piotr']])
+  end
+
+  specify 'fetching an object from a relation' do
+    TEST_ENV.session 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
+    TEST_ENV.session 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
+    TEST_ENV.session 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
+    TEST_ENV.session 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
+
+  specify 'updating an immutable object in a relation' do
+    TEST_ENV.session do |session|
+      jane = session[:users].restrict(id: 2).one
+
+      jane.freeze
+
+      session[:users].update_attributes(jane, name: 'Jane Doe')
+
+      session.flush
+
+      expect(relation.count).to be(2)
+
+      expect(relation.to_a.last).to eql(jane.update(name: 'Jane Doe'))
+    end
+  end
+end

data/spec/integration/wrapped_mappers_spec.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Wrapped mappers' do
+  let(:env) do
+    Environment.setup(test: 'memory://test') do
+      schema do
+        base_relation :users do
+          repository :test
+
+          attribute :id,   Integer
+          attribute :name, String
+
+          key :id
+        end
+
+        base_relation :tasks do
+          repository :test
+
+          attribute :id, Integer
+          attribute :title, String
+
+          key :id
+        end
+      end
+
+      mapping do
+        relation(:users) do
+          model User
+          map :id, :name
+        end
+
+        relation(:tasks) do
+          model Task
+          map :id, :title
+        end
+      end
+    end
+  end
+
+  before do
+    User = mock_model(:id, :name)
+    Task = mock_model(:id, :title, :user)
+  end
+
+  after do
+    Object.send(:remove_const, :User) if defined?(User)
+    Object.send(:remove_const, :Task) if defined?(Task)
+  end
+
+  subject(:mapper) { env[:tasks].mapper.wrap(:user => env[:users].mapper) }
+
+  specify 'loading wrapped tuples' do
+    tuple = { :id => 1, :title => 'Task 1', :user => { :id => 2, :name => 'Jane' } }
+
+    user = User.new(tuple[:user])
+    task = Task.new(:id => tuple[:id], :title => tuple[:title], :user => user)
+
+    expect(mapper.load(tuple)).to eql(task)
+  end
+
+  specify 'dumping wrapped tuples' do
+    mapper = env[:tasks].mapper.wrap(:user => env[:users].mapper)
+
+    tuple = { :id => 1, :title => 'Task 1', :user => { :id => 2, :name => 'Jane' } }
+
+    user = User.new(tuple[:user])
+    task = Task.new(:id => tuple[:id], :title => tuple[:title], :user => user)
+
+    expect(mapper.dump(task)).to eql([1, 'Task 1', [2, 'Jane']])
+  end
+end

data/spec/shared/unit/environment_context.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+shared_context 'Environment' do
+  let(:object) { Environment.setup(test: 'memory://test').finalize }
+  let(:uri)    { 'memory://test' }
+end

data/spec/shared/unit/loader.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+shared_examples_for 'Mapper::Loader' do
+  subject(:loader) { described_class.new(header, model, transformer) }
+
+  let(:header)      { Mapper::Header.build([[:id, type: Integer, key: true], [:name, type: String]]) }
+  let(:tuple)       { Hash[id: 1, name: 'Jane', something: 'foo'] }
+  let(:model)       { mock_model(:id, :name) }
+  let(:object)      { model.new(id: 1, name: 'Jane') }
+  let(:transformer) { fake('transformer') { Morpher::Evaluator::Transformer } }
+end

data/spec/shared/unit/loader_identity.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+shared_examples_for 'Mapper::Loader#identity' do
+  subject(:loader) { described_class.build(header, model) }
+
+  let(:header) { Mapper::Header.build([[:id, Integer], [:name, String]], keys: [:id]) }
+  let(:tuple)  { Hash[id: 1, name: 'Jane'] }
+  let(:model)  { mock_model(:id, :name) }
+
+  it "returns object's identity" do
+    expect(loader.identity(tuple)).to eq([1])
+  end
+end

data/spec/shared/unit/mapper_context.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+shared_context 'Mapper' do
+  let(:mapper) { described_class.build([[:id, key: true], [:name]], model: model) }
+
+  let(:header) { fake(:header) { Mapper::Header } }
+  let(:data)   { [1, 'Jane'] }
+  let(:tuple)  { Hash[id: 1, name: 'Jane'] }
+  let(:object) { model.new(id: 1, name: 'Jane') }
+  let(:model)  { mock_model(:id, :name) }
+end

data/spec/shared/unit/relation_context.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+shared_context 'Relation' do
+  subject(:relation) { described_class.new(users, mapper) }
+
+  let(:header) {
+    Axiom::Relation::Header.coerce([[:id, Integer], [:name, String]], keys: [:id])
+  }
+
+  let(:users) {
+    Axiom::Relation.new(header, [
+      [1, 'John'], [2, 'Jane'], [3, 'Jack'], [4, 'Jade']
+    ])
+  }
+
+  let(:model)  { mock_model(:id, :name) }
+  let(:mapper) { TestMapper.new(users.header, model) }
+
+  let(:john) { model.new(id: 1, name: 'John') }
+  let(:jane) { model.new(id: 2, name: 'Jane') }
+  let(:jack) { model.new(id: 3, name: 'Jack') }
+  let(:jade) { model.new(id: 4, name: 'Jade') }
+end
+
+shared_context 'Project with tasks' do
+  subject(:relation) { described_class.new(projects_with_tasks, mapper) }
+
+  let(:header) {
+    Axiom::Relation::Header.coerce(
+      [
+        [:id,        Integer],
+        [:name,      String ],
+        [:task_id,   Integer],
+        [:task_name, String ],
+      ]
+    )
+  }
+
+  let(:projects_with_tasks) {
+    Axiom::Relation.new(header, [
+      [1, 'rom-relation', 1, 'Add ROM::Relation#group'  ],
+      [1, 'rom-relation', 2, 'Add ROM::Relation#ungroup'],
+    ])
+  }
+
+  let(:project_with_tasks_model) { mock_model(:id, :name, :tasks) }
+  let(:task_model)               { mock_model(:task_id, :task_name) }
+
+  let(:mapper) { ProjectWithTasksMapper.new(header, project_with_tasks_model, task_model) }
+
+  let(:project_with_tasks) {
+    project_with_tasks_model.new(id: 1, name: 'rom-relation', tasks: tasks)
+  }
+
+  let(:tasks) {[
+    # TODO add renaming support: [[:id, Integer], [:name, String]]
+    task_model.new(task_id: 1, task_name: 'Add ROM::Relation#group'),
+    task_model.new(task_id: 2, task_name: 'Add ROM::Relation#ungroup')
+  ]}
+end
+
+shared_context 'City with location' do
+  subject(:relation) { described_class.new(city_relation, mapper) }
+
+  let(:header) {
+    Axiom::Relation::Header.coerce([
+      [:id, Integer], [:name, String], [:location_id, Integer], [:lat, Float], [:lng, Float]
+    ])
+  }
+
+  let(:city_relation) {
+    Axiom::Relation.new(header, [[1, 'Krakow', 1, 2.0, 3.0]])
+  }
+
+  let(:city_model) { mock_model(:id, :name, :location) }
+  let(:location_model) { mock_model(:lat, :lng) }
+
+  let(:mapper) { CityWithLocationMapper.new(header, city_model, location_model) }
+
+  let(:city) { city_model.new(id: 1, name: 'Krakow', location: location) }
+  let(:location) { location_model.new(lat: 2.0, lng: 3.0) }
+end

data/spec/shared/unit/session_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([[:id], [:name]], model: mock_model(:id, :name))
+    Relation.new(relation, mapper)
+  }
+end

data/spec/shared/unit/session_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, type: Integer, key: true], [:name, type: String]], model: model) }
+  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,49 @@
+# 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
+
+require 'devtools/spec_helper'
+
+require 'rom'
+
+require 'bogus/rspec'
+
+include ROM
+include SpecHelper
+include Morpher::NodeHelpers
+
+TEST_ENV = Environment.setup(test: 'memory://test') do
+  schema do
+    base_relation :users do
+      repository :test
+
+      attribute :id,   Integer
+      attribute :name, String
+
+      key :id
+    end
+  end
+
+  mapping do
+    relation(:users) do
+      model mock_model(:id, :name)
+      map :id, :name
+    end
+  end
+end

data/spec/support/helper.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module SpecHelper
+
+  def mock_model(*attributes, &block)
+    model = Class.new {
+      include Equalizer.new(*attributes)
+
+      const_set(:ATTRIBUTES, attributes)
+
+      attributes.each { |name| attr_accessor name }
+
+      def initialize(attrs = {}, &block)
+        attrs.each { |name, value| send("#{name}=", value) }
+        instance_eval(&block) if block
+      end
+
+      def update(tuple)
+        self.class.new(to_h.update(tuple))
+      end
+
+      def attribute_names
+        self.class.const_get(:ATTRIBUTES)
+      end
+
+      def to_h
+        attribute_names.each_with_object({}) { |name, h| h[name] = send(name) }
+      end
+    }
+    model.class_eval(&block) if block
+    model
+  end
+
+end

data/spec/support/ice_nine_config.rb

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+
+require 'ice_nine'
+
+module IceNine
+  class Freezer
+    class RSpec < NoFreeze
+    end
+  end
+end

data/spec/support/test_mapper.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+class TestMapper < Struct.new(:header, :model)
+
+  def call(relation)
+    relation
+  end
+
+  def load(tuple)
+    model.new(
+      Hash[
+        header.map { |attribute| [attribute.name, tuple[attribute.name]] }
+      ]
+    )
+  end
+
+  def dump(object)
+    header.each_with_object([]) { |attribute, tuple|
+      tuple << object.send(attribute.name)
+    }
+  end
+
+end
+
+class CityWithLocationMapper < Struct.new(:header, :model, :location_model)
+  attr_reader :city_header
+  attr_reader :location_header
+
+  def initialize(header, model, location_model)
+    super
+    @city_header = header.project(city_header_names)
+    @location_header = header.project(location_header_names)
+  end
+
+  def call(relation)
+    relation
+  end
+
+  def load(tuple)
+    model.new(city_attributes(tuple).merge(location: location_object(tuple[:location])))
+  end
+
+  def dump(object)
+    raise NotImplementedError, "#{self.class}##{__method__} must be implemented"
+  end
+
+  private
+
+  def city_attributes(tuple)
+    Hash[city_header.map { |attribute| [attribute.name, tuple[attribute.name]] }]
+  end
+
+  def location_object(tuple)
+    TestMapper.new(location_header, location_model).load(tuple)
+  end
+
+  def city_header_names
+    [:id, :name]
+  end
+
+  def location_header_names
+    [:lat, :lng]
+  end
+
+end
+
+class ProjectWithTasksMapper < Struct.new(:header, :model, :task_model)
+  attr_reader :task_header
+  attr_reader :project_header
+
+  def initialize(header, model, task_model)
+    super
+    @task_header    = header.project(task_header_names)#.rename(task_aliases)
+    @project_header = header.project(project_header_names)
+  end
+
+  def call(relation)
+    relation
+  end
+
+  def load(tuple)
+    model.new(project_attributes(tuple).merge(tasks: task_collection(tuple)))
+  end
+
+  def dump(object)
+    raise NotImplementedError, "#{self.class}##{__method__} must be implemented"
+  end
+
+  private
+
+  def project_attributes(tuple)
+    Hash[project_header.map { |attribute| [attribute.name, tuple[attribute.name]] }]
+  end
+
+  def task_collection(tuple)
+    tuple[:tasks].map(&method(:task_object))
+  end
+
+  def task_object(task_tuple)
+    TestMapper.new(task_header, task_model).load(task_tuple)#.rename(task_aliases))
+  end
+
+  def task_header_names
+    [:task_id, :task_name]
+  end
+
+  def project_header_names
+    [:id, :name]
+  end
+end