rom 0.2.0 → 0.3.0

data/lib/rom/repository.rb

@@ -1,71 +1,46 @@
-# encoding: utf-8
-
-require 'rom/support/axiom/adapter'
-
 module ROM
 
-  # A repository with a given +name+ and +adapter+
+  # Repository exposes native database connection and schema when it's
+  # supported by the adapter
   #
-  # @api private
+  # @api public
   class Repository
-    include Concord.new(:name, :adapter, :relations)
+    include Concord::Public.new(:adapter)
 
-    # Build a repository with a given +name+ and +uri+
-    #
-    # @param [Symbol] name
-    #   the repository's name
+    # Return the dataset identified by name
     #
-    # @param [Addressable::URI] uri
-    #   the uri for initializing the adapter
+    # @param [String,Symbol] name
     #
-    # @return [Repository]
-    #
-    # @api private
-    def self.build(name, uri, relations = {})
-      new(name, Axiom::Adapter.build(uri), relations)
+    # @api public
+    def [](name)
+      adapter[name]
     end
 
-    # Return the relation identified by +name+
-    #
-    # @example
-    #
-    #   repo = Repository.coerce(:test, 'in_memory://test')
-    #   repo.register(:foo, [[:id, String], [:foo, String]])
-    #   repo[:foo]
-    #
-    #   # => <Axiom::Relation header=Axiom::Header ...>
-    #
-    # @param [Symbol] name
-    #   the name of the relation
-    #
-    # @return [Axiom::Relation]
-    #
-    # @raise [KeyError]
+    # Return the database connection provided by the adapter
     #
     # @api public
-    def [](name)
-      relations.fetch(name)
+    def connection
+      adapter.connection
     end
 
-    # Register a relation with this repository
-    #
-    # @param [Axiom::Relation::Base] relation
+    # Return the schema provided by the adapter
     #
-    # @return [Object] relation gateway
-    #
-    # @api public
-    def []=(name, relation)
-      relation =
-        if adapter.respond_to?(:gateway)
-          adapter.gateway(relation)
-        else
-          adapter[name] = relation
-          adapter[name]
-        end
+    # @api private
+    def schema
+      adapter.schema
+    end
 
-      relations[name] = relation
+    # @api private
+    def respond_to_missing?(name, include_private = false)
+      adapter[name]
     end
 
-  end # Repository
+    private
+
+    # @api private
+    def method_missing(name)
+      adapter[name]
+    end
+  end
 
-end # ROM
+end

data/lib/rom/support/registry.rb

@@ -0,0 +1,34 @@
+module ROM
+
+  # @api private
+  class Registry
+    include Enumerable
+
+    attr_reader :elements
+
+    def initialize(elements = {})
+      @elements = elements
+    end
+
+    def each(&block)
+      return to_enum unless block
+      elements.each(&block)
+    end
+
+    def [](name)
+      elements[name]
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      key?(name) || super
+    end
+
+    private
+
+    def method_missing(name, *args)
+      self[name]
+    end
+
+  end
+
+end

data/lib/rom/version.rb

@@ -0,0 +1,3 @@
+module ROM
+  VERSION = '0.3.0'.freeze
+end

data/rom.gemspec

@@ -1,13 +1,13 @@
 # encoding: utf-8
 
-require File.expand_path('../lib/version', __FILE__)
+require File.expand_path('../lib/rom/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.name          = 'rom'
   gem.summary       = 'Ruby Object Mapper'
   gem.description   = gem.summary
-  gem.authors       = ['Piotr Solnica', 'Dan Kubb', 'Markus Schirp', 'Martin Gamsjaeger'].sort
-  gem.email         = ['piotr.solnica@gmail.com', 'dan.kubb@gmail.com', 'mbj@schirp-dso.com', 'gamsnjaga@gmail.com'].sort
+  gem.authors       = 'Piotr Solnica',
+  gem.email         = 'piotr.solnica@gmail.com'
   gem.homepage      = 'http://rom-rb.org'
   gem.require_paths = ['lib']
   gem.version       = ROM::VERSION.dup
@@ -15,11 +15,13 @@ Gem::Specification.new do |gem|
   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'
-  gem.add_dependency 'adamantium',      '~> 0.2'
-  gem.add_dependency 'axiom',           '~> 0.2'
-  gem.add_dependency 'axiom-optimizer', '~> 0.2'
-  gem.add_dependency 'charlatan',       '~> 0.1'
-  gem.add_dependency 'morpher',         '~> 0.2'
+  gem.add_runtime_dependency 'addressable', '~> 2.3'
+  gem.add_runtime_dependency 'equalizer',   '~> 0.0', '>= 0.0.9'
+  gem.add_runtime_dependency 'concord',     '~> 0.1', '>= 0.1.4'
+  gem.add_runtime_dependency 'charlatan',   '~> 0.1', '>= 0.1'
+  gem.add_runtime_dependency 'inflecto',    '~> 0.0', '>= 0.0.2'
+
+  gem.add_development_dependency 'rake', '~> 10.3'
+  gem.add_development_dependency 'rspec-core', '~> 3.1'
+  gem.add_development_dependency 'rspec-expectations', '~> 3.1'
 end

data/spec/integration/adapters/extending_relations_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe "Adapter" do
+  include_context "users and tasks" do
+    before(:all) do
+      Class.new(ROM::Adapter::Memory) do
+        def self.schemes
+          [:memory]
+        end
+
+        def extend_relation_class(klass)
+          klass.class_eval do
+            def self.freaking_awesome?
+              true
+            end
+          end
+        end
+
+        def extend_relation_instance(relation)
+          relation.instance_eval do
+            def freaking_cool?
+              true
+            end
+          end
+        end
+
+        ROM::Adapter.register(self)
+      end
+    end
+  end
+
+  before do
+    setup.relation(:users)
+  end
+
+  it "can extend relation class" do
+    expect(rom.relations.users.class).to be_freaking_awesome
+  end
+
+  it "can extend relation instance" do
+    expect(rom.relations.users).to be_freaking_cool
+  end
+end

data/spec/integration/mappers/definition_dsl_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe 'Mapper definition DSL' do
+  include_context 'users and tasks'
+
+  let(:header) { mapper.header }
+
+  before do
+    setup.relation(:users) do
+      def email_index
+        project(:email)
+      end
+    end
+  end
+
+  describe 'default PORO mapper' do
+    subject(:mapper) { rom.read(:users).mapper }
+
+    before do
+      setup.mappers do
+        define(:users) do
+          model name: 'User'
+        end
+      end
+    end
+
+    it 'defines a constant for the model class' do
+      expect(mapper.model).to be(User)
+    end
+
+    it 'uses all attributes from the relation header by default' do
+      expect(header.keys).to eql(rom.relations.users.header)
+    end
+  end
+
+  describe 'excluding attributes' do
+    subject(:mapper) { rom.read(:users).mapper }
+
+    before do
+      setup.mappers do
+        define(:users) do
+          model name: 'User'
+
+          exclude :name
+        end
+      end
+    end
+
+    it 'only maps provided attributes' do
+      expect(header.keys).to eql([:email])
+    end
+  end
+
+  describe 'virtual relation mapper' do
+    subject(:mapper) { rom.read(:users).email_index.mapper }
+
+    before do
+      setup.mappers do
+        define(:users) do
+          model name: 'User'
+        end
+      end
+
+      setup.mappers do
+        define(:email_index, parent: :users) do
+          model name: 'UserWithoutName'
+          exclude :name
+        end
+      end
+    end
+
+    it 'inherits the attributes from the parent by default' do
+      expect(header.keys).to eql(rom.mappers[:users].header - [:name])
+    end
+
+    it 'builds a new model' do
+      expect(mapper.model).to be(UserWithoutName)
+    end
+
+  end
+
+end

data/spec/integration/mappers/prefixing_attributes_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Mappers / Prefixing attributes' do
+  let(:setup) { ROM.setup(memory: 'memory://test') }
+
+  before do
+    setup.schema do
+      base_relation(:users) do
+        repository :memory
+
+        attribute :user_id
+        attribute :user_name
+        attribute :user_email
+      end
+    end
+
+    setup.relation(:users)
+  end
+
+  it 'automatically maps all attributes using the provided prefix' do
+    setup.mappers do
+      define(:users, prefix: :user) do
+        model name: 'User'
+
+        attribute :id
+        attribute :name
+        attribute :email
+      end
+    end
+
+    rom = setup.finalize
+
+    User.send(:include, Equalizer.new(:id, :name, :email))
+
+    rom.schema.users << { user_id: 123, user_name: 'Jane', user_email: 'jane@doe.org' }
+
+    jane = rom.read(:users).to_a.first
+
+    expect(jane).to eql(User.new(id: 123, name: 'Jane', email: 'jane@doe.org'))
+  end
+
+end

data/spec/integration/mappers/renaming_attributes_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe 'Mappers / Renaming attributes' do
+  let(:setup) { ROM.setup(memory: 'memory://test') }
+
+  before do
+    setup.schema do
+      base_relation(:users) do
+        repository :memory
+
+        attribute :_id
+        attribute :user_name
+      end
+
+      base_relation(:addresses) do
+        repository :memory
+
+        attribute :address_id
+        attribute :address_street
+      end
+    end
+
+    setup.relation(:addresses)
+
+    setup.relation(:users) do
+      def with_address
+        in_memory {
+          wrap(join(users, addresses), address: [:address_id, :address_street])
+        }
+      end
+
+      def with_addresses
+        in_memory {
+          group(join(users, addresses), addresses: [:address_id, :address_street])
+        }
+      end
+    end
+  end
+
+  it 'maps renamed attributes for a base relation' do
+    setup.mappers do
+      define(:users) do
+        model name: 'User'
+
+        attribute :id, from: :_id
+        attribute :name, from: :user_name
+      end
+    end
+
+    rom = setup.finalize
+
+    User.send(:include, Equalizer.new(:id, :name))
+
+    rom.schema.users << { _id: 123, user_name: 'Jane' }
+
+    jane = rom.read(:users).to_a.first
+
+    expect(jane).to eql(User.new(id: 123, name: 'Jane'))
+  end
+
+  it 'maps renamed attributes for a wrapped relation' do
+    setup.mappers do
+      define(:users) do
+        model name: 'User'
+
+        attribute :id, from: :_id
+        attribute :name, from: :user_name
+      end
+
+      define(:with_address, parent: :users) do
+        model name: 'UserWithAddress'
+
+        attribute :id, from: :_id
+        attribute :name, from: :user_name
+
+        wrap :address do
+          attribute :id, from: :address_id
+          attribute :street, from: :address_street
+        end
+      end
+    end
+
+    rom = setup.finalize
+
+    UserWithAddress.send(:include, Equalizer.new(:id, :name, :address))
+
+    rom.schema.users << { _id: 123, user_name: 'Jane' }
+    rom.schema.addresses << { _id: 123, address_id: 321, address_street: 'Street 1' }
+
+    jane = rom.read(:users).with_address.first
+
+    expect(jane).to eql(
+      UserWithAddress.new(id: 123, name: 'Jane', address: { id: 321, street: 'Street 1' })
+    )
+  end
+
+  it 'maps renamed attributes for a grouped relation' do
+    setup.mappers do
+      define(:users) do
+        model name: 'User'
+
+        attribute :id, from: :_id
+        attribute :name, from: :user_name
+      end
+
+      define(:with_addresses, parent: :users) do
+        model name: 'UserWithAddresses'
+
+        attribute :id, from: :_id
+        attribute :name, from: :user_name
+
+        group :addresses do
+          attribute :id, from: :address_id
+          attribute :street, from: :address_street
+        end
+      end
+    end
+
+    rom = setup.finalize
+
+    UserWithAddresses.send(:include, Equalizer.new(:id, :name, :addresses))
+
+    rom.schema.users << { _id: 123, user_name: 'Jane' }
+    rom.schema.addresses << { _id: 123, address_id: 321, address_street: 'Street 1' }
+    rom.schema.addresses << { _id: 123, address_id: 654, address_street: 'Street 2' }
+
+    jane = rom.read(:users).with_addresses.first
+
+    expect(jane).to eql(
+      UserWithAddresses.new(
+        id: 123,
+        name: 'Jane',
+        addresses: [{ id: 321, street: 'Street 1' },
+                    { id: 654, street: 'Street 2' }]
+      )
+    )
+  end
+end