rom 0.2.0 → 0.3.0

data/spec/integration/session_spec.rb

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

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

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

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

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

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

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

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

@@ -1,18 +0,0 @@
-# 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/support/helper.rb

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

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

data/spec/support/test_mapper.rb

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