rom-relation 0.1.0

data/lib/rom/support/axiom/adapter/memory.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'axiom-memory-adapter'
+require 'rom/support/axiom/adapter'
+
+module Axiom
+  module Adapter
+
+    # A axiom in memory adapter
+    #
+    # This is basically a "null adapter"
+    # as it doesn't make use of it's uri
+    # and only passes through the given
+    # +relation+ in {#gateway}
+    #
+    class Memory
+      extend Adapter
+
+      include Equalizer.new(:schema)
+
+      uri_scheme :memory
+
+    end # class Memory
+  end # module Adapter
+end # module Axiom

data/lib/rom/support/axiom/adapter/postgres.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'do_postgres'
+
+require 'rom/support/axiom/adapter'
+require 'rom/support/axiom/adapter/data_objects'
+
+module Axiom
+  module Adapter
+
+    # A Axiom adapter for postgres
+    #
+    class Postgres < DataObjects
+
+      uri_scheme :postgres
+
+    end # class Postgres
+  end # module Adapter
+end # module Axiom

data/lib/rom/support/axiom/adapter/sqlite3.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'do_sqlite3'
+
+require 'rom/support/axiom/adapter'
+require 'rom/support/axiom/adapter/data_objects'
+
+module Axiom
+  module Adapter
+
+    # A axiom adapter for sqlite3
+    #
+    class Sqlite3 < DataObjects
+
+      uri_scheme :sqlite3
+
+    end # class Sqlite3
+  end # module Adapter
+end # module Axiom

data/lib/rom/support/axiom/adapter.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+module Axiom
+
+  # Raised when passing an +uri+ with an unregistered scheme to {Adapter.new}
+  UnknownAdapterError = Class.new(StandardError)
+
+  # Provides base functionality for every axiom adapter
+  #
+  # @todo think about making this a (base) class
+  #
+  # @example
+  #
+  #   class MyAdapter
+  #     extend Axiom::Adapter
+  #     uri_scheme :foo
+  #   end
+  #
+  module Adapter
+
+    # The registry of adapters
+    #
+    # @return [Hash<String, Object>]
+    #   a hash of adapters, keyed by uri scheme
+    #
+    # @api private
+    REGISTRY = {}
+
+    # Return the adapter to use for the given +uri+
+    #
+    # @param [Addressable::URI] uri
+    #   the uri to initialize the adapter with
+    #
+    # @return [Object]
+    #   a axiom adapter
+    #
+    # @raise [UnknownAdapterError]
+    #   when the given +uri+'s scheme is not registered
+    #
+    # @api private
+    def self.build(uri)
+      klass = get(uri)
+
+      if klass.name == 'Axiom::Adapter::Memory'
+        klass.new
+      else
+        klass.new(uri)
+      end
+    end
+
+    # Return the adapter class registered for +uri+
+    #
+    # @param [Addressable::URI] uri
+    #   the uri that identifies the adapter class
+    #
+    # @return [Class]
+    #   a axiom adapter class
+    #
+    # @raise [UnknownAdapterError]
+    #   when the given +uri+'s scheme is not registered
+    #
+    # @api private
+    def self.get(uri)
+      uri_scheme = uri.scheme
+
+      REGISTRY.fetch(uri_scheme) {
+        raise(
+          UnknownAdapterError,
+          "#{uri_scheme.inspect} is no registered uri scheme"
+        )
+      }
+    end
+
+    # Set the uri scheme for an adapter class
+    #
+    # @example for a DataObjects adapter
+    #
+    #   class Postgres < Axiom::Adapter::DataObjects
+    #     uri_scheme :postgres
+    #   end
+    #
+    # @example for an arbitrary adapter
+    #
+    #   class InMemory
+    #     extend Axiom::Adapter
+    #     uri_scheme :in_memory
+    #   end
+    #
+    # @param [#to_s] name
+    #   the name of the uri scheme
+    #
+    # @return [self]
+    #
+    # @api public
+    def uri_scheme(name)
+      REGISTRY[name.to_s] = self
+    end
+
+  end # module Adapter
+end # module Axiom

data/lib/rom/version.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+module ROM
+  class Relation
+    VERSION = '0.1.0'
+  end
+end

data/lib/rom-relation.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'addressable/uri'
+
+require 'set'
+require 'concord'
+require 'abstract_type'
+require 'descendants_tracker'
+require 'equalizer'
+require 'axiom'
+
+# Main ROM module with methods to setup and manage the environment
+module ROM
+
+  # Raised when the returned tuples are unexpectedly empty
+  NoTuplesError = Class.new(RuntimeError)
+
+  # Raised when the returned tuples are unexpectedly too many
+  ManyTuplesError = Class.new(RuntimeError)
+
+  # Represent an undefined argument
+  Undefined = Object.new.freeze
+
+  # An empty frozen Hash useful for parameter default values
+  EMPTY_HASH = {}.freeze
+
+  # An empty frozen Array useful for parameter default values
+  EMPTY_ARRAY = [].freeze
+
+  # Represent a positive, infinitely large Float number
+  Infinity  = 1.0 / 0
+
+end # module ROM
+
+require 'rom/repository'
+require 'rom/environment'
+require 'rom/relation'
+
+require 'rom/schema'
+require 'rom/schema/definition'
+require 'rom/schema/definition/relation'
+require 'rom/schema/definition/relation/base'
+
+require 'rom/mapping'
+require 'rom/mapping/definition'

data/rom-relation.gemspec

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/rom/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'rom-relation'
+  gem.summary       = 'Relation schema with mapping for ROM'
+  gem.description   = gem.summary
+  gem.authors       = 'Piotr Solnica'
+  gem.email         = 'piotr.solnica@gmail.com'
+  gem.homepage      = 'http://rom-rb.org'
+  gem.require_paths = ['lib']
+  gem.version       = ROM::Relation::VERSION
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  gem.license       = 'MIT'
+
+  gem.add_dependency 'addressable',         '~> 2.3', '>= 2.3.3'
+  gem.add_dependency 'concord',             '~> 0.1.4'
+  gem.add_dependency 'equalizer',           '~> 0.0.7'
+  gem.add_dependency 'descendants_tracker', '~> 0.0.1'
+  gem.add_dependency 'abstract_type',       '~> 0.0.6'
+  gem.add_dependency 'adamantium',          '~> 0.1'
+  gem.add_dependency 'axiom',               '~> 0.1.1'
+  gem.add_dependency 'axiom-optimizer',     '~> 0.1.0'
+end

data/spec/integration/environment_setup_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Setting up environment' do
+  it 'registers relations within repositories' do
+    env = ROM::Environment.setup(memory: 'memory://test')
+
+    schema = env.schema do
+      base_relation :users do
+        repository :memory
+
+        attribute :id,   Integer
+        attribute :name, String
+
+        key :id
+      end
+    end
+
+    expect(schema[:users]).to be_instance_of(Axiom::Relation::Variable)
+  end
+end

data/spec/integration/mapping_relations_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Defining relation mappings' do
+  let!(:schema) {
+    env.schema {
+      base_relation :users do
+        repository :test
+
+        attribute :id,        Integer
+        attribute :user_name, String
+
+        key :id
+      end
+    }
+  }
+
+  let!(:env) {
+    Environment.setup(test: 'memory://test')
+  }
+
+  before do
+    User = mock_model(:id, :name)
+  end
+
+  after do
+    Object.send(:remove_const, :User)
+  end
+
+  specify 'building registry of automatically mapped relations' do
+    env.mapping do
+      users do
+        model User
+
+        map :id
+        map :user_name, to: :name
+      end
+    end
+
+    users = env[:users]
+
+    jane = User.new(id: 1, name: 'Jane')
+
+    users.insert(jane)
+
+    expect(users.to_a).to eql([jane])
+  end
+
+  specify 'providing custom mapper' do
+    custom_model  = mock_model(:id, :user_name)
+    custom_mapper = TestMapper.new(schema[:users].header, custom_model)
+
+    env.mapping { users { mapper(custom_mapper) } }
+
+    users = env[:users]
+
+    jane = custom_model.new(id: 1, user_name: 'Jane')
+
+    users.insert(jane)
+
+    expect(users.to_a).to eql([jane])
+  end
+end

data/spec/integration/schema_definition_spec.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Defining a ROM schema' do
+  let(:people) {
+    Axiom::Relation::Base.new(:people, people_header)
+  }
+
+  let(:people_header) {
+    Axiom::Relation::Header.coerce(people_attributes, keys: people_keys)
+  }
+
+  let(:people_attributes) {
+    [[:id, Integer], [:name, String]]
+  }
+
+  let(:people_keys) {
+    [:id]
+  }
+
+  let(:profiles) {
+    Axiom::Relation::Base.new(:profiles, profiles_header)
+  }
+
+  let(:profiles_header) {
+    Axiom::Relation::Header.coerce(profiles_attributes, keys: profiles_keys)
+  }
+
+  let(:profiles_attributes) {
+    [[:id, Integer], [:person_id, Integer], [:text, String]]
+  }
+
+  let(:profiles_keys) {
+    [:id, :person_id]
+  }
+
+  let(:people_with_profile) {
+    people.join(profiles.rename(id: :profile_id, person_id: :id))
+  }
+
+  let(:env)        { Environment.setup(test: 'memory://test') }
+  let(:repository) { env.repository(:test) }
+
+  let(:schema) do
+    env.schema do
+      base_relation :people do
+        repository :test
+
+        attribute :id,   Integer
+        attribute :name, String
+
+        key :id
+      end
+
+      base_relation :profiles do
+        repository :test
+
+        attribute :id,        Integer
+        attribute :person_id, Integer
+        attribute :text,      String
+
+        key :id
+        key :person_id
+      end
+    end
+
+    env.schema do
+      relation :people_with_profile do
+        people.join(profiles.rename(id: :profile_id, person_id: :id))
+      end
+    end
+  end
+
+  it 'registers the people relation' do
+    expect(schema[:people]).to eq(people)
+  end
+
+  it 'establishes key attributes for people relation' do
+    expect(schema[:people].header.keys).to include(*people_keys)
+  end
+
+  it 'establishes key attributes for profiles relation' do
+    expect(schema[:profiles].header.keys).to include(*profiles_keys)
+  end
+
+  it 'registers the profiles relation' do
+    expect(schema[:profiles]).to eq(profiles)
+  end
+
+  it 'registers the people_with_profile relation' do
+    expect(schema[:people_with_profile]).to eq(people_with_profile)
+  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') }
+  let(:uri)    { 'memory://test' }
+end

data/spec/shared/unit/relation_context.rb

@@ -0,0 +1,25 @@
+# # encoding: utf-8
+
+# 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

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+# SimpleCov MUST be started before require 'rom-relation'
+#
+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 'rom-relation'
+require 'rom-mapper'
+require 'rom/support/axiom/adapter/memory'
+
+require 'devtools/spec_helper'
+require 'bogus/rspec'
+
+include ROM
+
+ROM_ENV     = Environment.setup(test: 'memory://test')
+ROM_ADAPTER = ENV.fetch('ROM_ADAPTER', :in_memory).to_sym
+
+Bogus.configure do |config|
+  config.search_modules << ROM
+end
+
+RSpec.configure do |config|
+  config.include(SpecHelper)
+end

data/spec/support/helper.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module SpecHelper
+
+  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
+
+end

data/spec/support/test_mapper.rb

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

data/spec/unit/rom/environment/class_methods/setup_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Environment, '.setup' do
+  subject { described_class.setup(config) }
+
+  context 'when an environment is passed' do
+    let(:config)      { environment }
+    let(:environment) { described_class.setup(test: 'memory://test') }
+
+    it { should be(environment) }
+  end
+
+  context 'when a repository config hash is passed' do
+    let(:config) { { name => uri } }
+    let(:name)   { :test }
+    let(:uri)    { 'memory://test' }
+
+    let(:coerced_config) { Hash[test: Repository.build(name, coerced_uri)] }
+    let(:coerced_uri)    { Addressable::URI.parse(uri) }
+
+    it { should eq(described_class.new(coerced_config, {})) }
+  end
+end

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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Environment, '#[]' do
+  include_context 'Environment'
+
+  subject { object[:users] }
+
+  context 'when relation exists' do
+    fake(:relation, name: :users) { Axiom::Relation::Base }
+
+    before do
+      object[:users] = relation
+    end
+
+    it { should be(relation) }
+  end
+
+  context 'when relation does not exist' do
+    it { should be(nil) }
+  end
+end

data/spec/unit/rom/environment/mapping_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Environment, '#mapping' do
+  include_context 'Environment'
+
+  let!(:schema) do
+    object.schema do
+      base_relation(:users) do
+        repository :test
+        attribute :name, String
+      end
+    end
+  end
+
+  before do
+    object.mapping do
+      users { map :name }
+    end
+  end
+
+  it 'sets up rom relations' do
+    expect(object[:users]).to be_instance_of(Relation)
+  end
+end

data/spec/unit/rom/environment/repository_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Environment, '#repository' do
+  include_context 'Environment'
+
+  subject { object.repository(name) }
+
+  context 'when repository exists' do
+    let(:name) { :test }
+
+    it { should be_instance_of(Repository) }
+  end
+
+  context 'when is not known' do
+    let(:name) { :not_here }
+
+    it { should be(nil) }
+  end
+end

data/spec/unit/rom/environment/schema_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Environment, '#schema' do
+  let(:repositories) { Hash.new }
+  let(:object)       { Environment.build(repositories) }
+  let(:block)        { -> { } }
+
+  fake(:schema)
+
+  before do
+    fake_class(Schema, build: -> { schema })
+  end
+
+  describe 'with a block' do
+    subject { object.schema(&block) }
+
+    it 'calls the schema' do
+      expect(subject).to be(schema)
+      expect(schema).to have_received.call
+    end
+  end
+
+  describe 'without a block' do
+    subject { object.schema }
+
+    it 'calls the schema' do
+      expect(subject).to be(schema)
+      expect(schema).not_to have_received.call
+    end
+  end
+end