rom-sql 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fae231a134bab168af4e2cc51bc9f525839165aa
-  data.tar.gz: dcaa467ae85f00b2298d7a11ba24612bd1db17b6
+  metadata.gz: bbd3084b35810eb5773f42d14ae8c75de6d6de0f
+  data.tar.gz: 9dfa889eed6b3005a6c6385c70bceb78aa975fe5
 SHA512:
-  metadata.gz: 4279201898c5ff53884bd2dd1d8743baea691965bd2e26c573a9453001deff5fe1f6e17b37ec05b1bf6c67907ea7f2e40ecc75301746921c310a72c6a29b4a9d
-  data.tar.gz: 15878ffaebb4557cb9bd1b95fa3c1326d21a91017175f532cad871bb3cddeae039bf80f72e4139735ad932af589b3d6a05cf97c0269c2600c165e3d3c79f9914
+  metadata.gz: 9d2ac005bf0b9bd1ce789d9e34822581c66510c1861c3e5bb7d6b778bc8526ef287cfc77a3aa3e204eb5c8c2c744e88fb092417c66c3bb19d74734d022f70abb
+  data.tar.gz: f10f50b34e35e892014a394ae54e606d42bd8f8750c3640674e09116553c5b73a5846578a02e66c15011ceed60aa8d85d8e982a6bbef0ce482be18b66b28b4e2

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## v0.5.0 2015-05-22
+
+### Added
+
+* Association macros support addition `:on` option (solnic)
+* `associates` plugin for `Create` command (solnic)
+* Support for NotNullConstraintError (solnic)
+* Support for UniqueConstraintConstraintError (solnic)
+* Support for ForeignKeyConstraintError (solnic)
+* Support for CheckConstraintError (solnic)
+* `Commands::Update#original` supports objects coercible to_h now (solnic)
+
+### Changed
+
+* [BREAKING] Constraint errors are no longer command errors which means `try` and
+  `transaction` blocks will not catch them (solnic)
+* `Commands::Update#set` has been deprecated (solnic)
+* `Commands::Update#to` has been deprecated (solnic)
+
+[Compare v0.4.3...0.5.0](https://github.com/rom-rb/rom-sql/compare/v0.4.2...0.5.0)
+
 ## v0.4.3 2015-05-17
 
 ### Fixed

data/Gemfile

@@ -4,6 +4,7 @@ gemspec
 
 group :test do
   gem 'byebug', platforms: :mri
+  gem 'anima'
   gem 'rom', github: 'rom-rb/rom', branch: 'master'
   gem 'virtus'
   gem 'activesupport'

data/lib/rom/sql.rb

@@ -4,16 +4,43 @@ require "rom"
 module ROM
   module SQL
     NoAssociationError = Class.new(StandardError)
-    ConstraintError = Class.new(ROM::CommandError)
 
-    class DatabaseError < ROM::CommandError
+    class Error < StandardError
       attr_reader :original_exception
 
-      def initialize(error, message)
-        super(message)
-        @original_exception = error
+      def initialize(original_exception)
+        super(original_exception.message)
+        @original_exception = original_exception
+        set_backtrace(original_exception.backtrace)
       end
     end
+
+    DatabaseError = Class.new(Error)
+
+    ConstraintError = Class.new(Error)
+
+    NotNullConstraintError = Class.new(ConstraintError)
+    UniqueConstraintError = Class.new(ConstraintError)
+    ForeignKeyConstraintError = Class.new(ConstraintError)
+    CheckConstraintError = Class.new(ConstraintError)
+
+    ERROR_MAP = {
+      Sequel::DatabaseError => DatabaseError,
+      Sequel::NotNullConstraintViolation => NotNullConstraintError,
+      Sequel::UniqueConstraintViolation => UniqueConstraintError,
+      Sequel::ForeignKeyConstraintViolation => ForeignKeyConstraintError,
+      Sequel::CheckConstraintViolation => CheckConstraintError
+    }.freeze
+  end
+end
+
+require 'rom/sql/plugin/associates'
+require 'rom/sql/plugin/pagination'
+
+ROM.plugins do
+  adapter :sql do
+    register :pagination, ROM::SQL::Plugin::Pagination, type: :relation
+    register :associates, ROM::SQL::Plugin::Associates, type: :command
   end
 end
 
@@ -28,7 +55,3 @@ if defined?(Rails)
 end
 
 ROM.register_adapter(:sql, ROM::SQL)
-
-ROM.plugins do
-  register :pagination, ROM::SQL::Plugin::Pagination, type: :relation
-end

data/lib/rom/sql/commands.rb

@@ -1,16 +1,5 @@
 require 'rom/commands'
 
-module ROM
-  module SQL
-    module Commands
-      ERRORS = [
-        Sequel::UniqueConstraintViolation,
-        Sequel::NotNullConstraintViolation
-      ].freeze
-    end
-  end
-end
-
 require 'rom/sql/commands/create'
 require 'rom/sql/commands/update'
 require 'rom/sql/commands/delete'

data/lib/rom/sql/commands/create.rb

@@ -5,12 +5,22 @@ require 'rom/sql/commands/transaction'
 module ROM
   module SQL
     module Commands
+      # SQL create command
+      #
+      # @api public
       class Create < ROM::Commands::Create
+        adapter :sql
+
         include Transaction
         include ErrorWrapper
 
+        use :associates
+
+        # Inserts provided tuples into the database table
+        #
+        # @api public
         def execute(tuples)
-          insert_tuples = Array([tuples]).flatten.map do |tuple|
+          insert_tuples = with_input_tuples(tuples) do |tuple|
             attributes = input[tuple]
             validator.call(attributes)
             attributes.to_h
@@ -19,10 +29,24 @@ module ROM
           insert(insert_tuples)
         end
 
+        private
+
+        # Executes insert statement and returns inserted tuples
+        #
+        # @api private
         def insert(tuples)
           pks = tuples.map { |tuple| relation.insert(tuple) }
           relation.where(relation.primary_key => pks)
         end
+
+        # Yields tuples for insertion or return an enumerator
+        #
+        # @api private
+        def with_input_tuples(tuples)
+          input_tuples = Array([tuples]).flatten.map
+          return input_tuples unless block_given?
+          input_tuples.each { |tuple| yield(tuple) }
+        end
       end
     end
   end

data/lib/rom/sql/commands/delete.rb

@@ -5,10 +5,20 @@ require 'rom/sql/commands/transaction'
 module ROM
   module SQL
     module Commands
+      # SQL delete command
+      #
+      # @api public
       class Delete < ROM::Commands::Delete
+        adapter :sql
+
         include Transaction
         include ErrorWrapper
 
+        # Deletes tuples from a relation
+        #
+        # @return [Array<Hash>] deleted tuples
+        #
+        # @api public
         def execute
           deleted = target.to_a
           target.delete

data/lib/rom/sql/commands/error_wrapper.rb

@@ -1,13 +1,17 @@
 module ROM
   module SQL
     module Commands
+      # Shared error handler for all SQL commands
+      #
+      # @api private
       module ErrorWrapper
+        # Handle Sequel errors and re-raise ROM-specific errors
+        #
+        # @api public
         def call(*args)
           super
-        rescue *ERRORS => e
-          raise ConstraintError, e.message
-        rescue Sequel::DatabaseError => e
-          raise DatabaseError.new(e, e.message)
+        rescue *ERROR_MAP.keys => e
+          raise ERROR_MAP[e.class], e
         end
       end
     end

data/lib/rom/sql/commands/update.rb

@@ -1,3 +1,5 @@
+require 'rom/support/deprecations'
+
 require 'rom/sql/commands'
 require 'rom/sql/commands/error_wrapper'
 require 'rom/sql/commands/transaction'
@@ -5,15 +7,27 @@ require 'rom/sql/commands/transaction'
 module ROM
   module SQL
     module Commands
+      # Update command
+      #
+      # @api public
       class Update < ROM::Commands::Update
+        adapter :sql
+
+        include Deprecations
+
         include Transaction
         include ErrorWrapper
 
-        option :original, type: Hash, reader: true
+        option :original, reader: true
 
-        alias_method :to, :call
-        alias_method :set, :call
+        deprecate :set, :call
+        deprecate :to, :call
 
+        # Updates existing tuple in a relation
+        #
+        # @return [Array<Hash>, Hash]
+        #
+        # @api public
         def execute(tuple)
           attributes = input[tuple]
           validator.call(attributes)
@@ -27,10 +41,28 @@ module ROM
           end
         end
 
+        # Update existing tuple only when it changed
+        #
+        # @example
+        #   user = rom.relation(:users).one
+        #   new_user = { name: 'Jane Doe' }
+        #
+        #   rom.command(:users).change(user).call(new_user)
+        #
+        # @param [#to_h, Hash] original The original tuple
+        #
+        # @return [Command::Update]
+        #
+        # @api public
         def change(original)
-          self.class.new(relation, options.merge(original: original))
+          self.class.new(relation, options.merge(original: original.to_h))
         end
 
+        private
+
+        # Executes update statement for a given tuple
+        #
+        # @api private
         def update(tuple)
           pks = relation.map { |t| t[primary_key] }
           dataset = relation.dataset
@@ -38,12 +70,14 @@ module ROM
           dataset.unfiltered.where(primary_key => pks).to_a
         end
 
+        # @api private
         def primary_key
           relation.primary_key
         end
 
-        private
-
+        # Check if input tuple is different from the original one
+        #
+        # @api private
         def diff(tuple)
           if original
             Hash[tuple.to_a - (tuple.to_a & original.to_a)]

data/lib/rom/sql/plugin/associates.rb

@@ -0,0 +1,82 @@
+module ROM
+  module SQL
+    module Plugin
+      # Make a command that automaticaly sets FK attribute on input tuples
+      #
+      # @api private
+      module Associates
+        # @api private
+        def self.included(klass)
+          klass.extend(ClassMethods)
+          super
+        end
+
+        module InstanceMethods
+          # Set fk on tuples from parent tuple
+          #
+          # @param [Array<Hash>, Hash] tuples The input tuple(s)
+          # @param [Hash] parent The parent tuple with its pk already set
+          #
+          # @return [Array<Hash>,Hash]
+          #
+          # @overload SQL::Commands::Create#execute
+          #
+          # @api public
+          def execute(tuples, parent)
+            fk, pk = association[:key]
+
+            input_tuples = with_input_tuples(tuples).map { |tuple|
+              tuple.merge(fk => parent.fetch(pk))
+            }
+
+            super(input_tuples)
+          end
+        end
+
+        module ClassMethods
+          # @api private
+          def inherited(klass)
+            klass.defines :associations
+            klass.associations []
+            super
+          end
+
+          # Set command to associate tuples with a parent tuple using provided keys
+          #
+          # @example
+          #   class CreateTask < ROM::Commands::Create[:sql]
+          #     relation :tasks
+          #     associates :user, [:user_id, :id]
+          #   end
+          #
+          #   create_user = rom.command(:user).create.with(name: 'Jane')
+          #
+          #   create_tasks = rom.command(:tasks).create
+          #     .with [{ title: 'One' }, { title: 'Two' } ]
+          #
+          #   command = create_user >> create_tasks
+          #   command.call
+          #
+          # @param [Symbol] name The name of associated table
+          # @param [Hash] options The options
+          # @option options [Array] :key The association keys
+          #
+          # @api public
+          def associates(name, options)
+            if associations.include?(name)
+              raise(
+                ArgumentError,
+                "#{name} association is already defined for #{self.class}"
+              )
+            end
+
+            option :association, reader: true, default: -> command { options }
+            include InstanceMethods
+
+            associations << name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/relation.rb

@@ -4,19 +4,25 @@ require 'rom/sql/relation/class_methods'
 require 'rom/sql/relation/inspection'
 require 'rom/sql/relation/associations'
 
-require 'rom/sql/plugin/pagination'
-
 module ROM
   module SQL
     # Sequel-specific relation extensions
     #
     class Relation < ROM::Relation
+      adapter :sql
+
       extend ClassMethods
 
       include Inspection
       include Associations
 
-      attr_reader :header, :table
+      # @attr_reader [Header] header Internal lazy-initialized header
+      attr_reader :header
+
+      # Name of the table used in FROM clause
+      #
+      # @attr_reader [Symbol] table
+      attr_reader :table
 
       # @api private
       def initialize(dataset, registry = {})
@@ -24,44 +30,74 @@ module ROM
         @table = dataset.opts[:from].first
       end
 
-      # Return a header for this relation
+      # Project a relation
       #
-      # @return [Header]
+      # This method is intended to be used internally within a relation object
       #
-      # @api private
-      def header
-        @header ||= Header.new(dataset.opts[:select] || dataset.columns, table)
-      end
-
-      # Return raw column names
+      # @example
+      #   rom.relation(:users) { |r| r.project(:id, :name) }
       #
-      # @return [Array<Symbol>]
+      # @param [Symbol] names A list of symbol column names
+      #
+      # @return [Relation]
       #
-      # @api private
-      def columns
-        dataset.columns
-      end
-
       # @api public
       def project(*names)
         select(*header.project(*names))
       end
 
+      # Rename columns in a relation
+      #
+      # This method is intended to be used internally within a relation object
+      #
+      # @example
+      #   rom.relation(:users) { |r| r.rename(name: :user_name) }
+      #
+      # @param [Hash] options A name => new_name map
+      #
+      # @return [Relation]
+      #
       # @api public
       def rename(options)
         select(*header.rename(options))
       end
 
+      # Prefix all columns in a relation
+      #
+      # This method is intended to be used internally within a relation object
+      #
+      # @example
+      #   rom.relation(:users) { |r| r.prefix(:user) }
+      #
+      # @param [Symbol] name The prefix
+      #
+      # @return [Relation]
+      #
       # @api public
       def prefix(name = Inflector.singularize(table))
         rename(header.prefix(name).to_h)
       end
 
+      # Qualifies all columns in a relation
+      #
+      # This method is intended to be used internally within a relation object
+      #
+      # @example
+      #   rom.relation(:users) { |r| r.qualified }
+      #
+      # @return [Relation]
+      #
       # @api public
       def qualified
         select(*qualified_columns)
       end
 
+      # Return a list of qualified column names
+      #
+      # This method is intended to be used internally within a relation object
+      #
+      # @return [Relation]
+      #
       # @api public
       def qualified_columns
         header.qualified.to_a
@@ -341,6 +377,24 @@ module ROM
       def unique?(criteria)
         where(criteria).count.zero?
       end
+
+      # Return a header for this relation
+      #
+      # @return [Header]
+      #
+      # @api private
+      def header
+        @header ||= Header.new(dataset.opts[:select] || dataset.columns, table)
+      end
+
+      # Return raw column names
+      #
+      # @return [Array<Symbol>]
+      #
+      # @api private
+      def columns
+        dataset.columns
+      end
     end
   end
 end

data/lib/rom/sql/relation/associations.rb

@@ -54,7 +54,6 @@ module ROM
               "defined for relation #{name.inspect}"
           end
 
-          key = assoc[:key]
           type = assoc[:type]
           table_name = assoc[:class].table_name
 
@@ -63,7 +62,7 @@ module ROM
               select = options[:select] || {}
               graph_join_many_to_many(table_name, assoc, select)
             else
-              graph_join_other(table_name, key, type, join_type, options)
+              graph_join_other(table_name, assoc, type, join_type, options)
             end
 
           graph_rel = graph_rel.where(assoc[:conditions]) if assoc[:conditions]
@@ -97,13 +96,16 @@ module ROM
           )
         end
 
-        def graph_join_other(name, key, type, join_type, options)
+        def graph_join_other(name, assoc, type, join_type, options)
+          key = assoc[:key]
+          on_conditions = assoc[:on] || {}
+
           join_keys =
             if type == :many_to_one
               { primary_key => key }
             else
               { key => primary_key }
-            end
+            end.merge(on_conditions)
 
           graph(
             name, join_keys,

data/lib/rom/sql/relation/class_methods.rb

@@ -1,7 +1,13 @@
 module ROM
   module SQL
     class Relation < ROM::Relation
+      # Class DSL for SQL relations
+      #
+      # @api private
       module ClassMethods
+        # Set up model and association ivars for descendant class
+        #
+        # @api private
         def inherited(klass)
           klass.class_eval do
             class << self
@@ -13,20 +19,83 @@ module ROM
           super
         end
 
+        # Set up a one-to-many association
+        #
+        # @example
+        #   class Users < ROM::Relation[:sql]
+        #     one_to_many :tasks, key: :user_id
+        #
+        #     def with_tasks
+        #       association_join(:tasks)
+        #     end
+        #   end
+        #
+        # @param [Symbol] name The name of the association
+        # @param [Hash] options The options hash
+        # @option options [Symbol] :key Name of the key to join on
+        # @option options [Hash] :on Additional conditions for join
+        # @option options [Hash] :conditions Additional conditions for WHERE
+        #
+        # @api public
         def one_to_many(name, options)
           associations << [__method__, name, { relation: name }.merge(options)]
         end
 
+        # Set up a many-to-many association
+        #
+        # @example
+        #   class Tasks < ROM::Relation[:sql]
+        #     many_to_many :tags,
+        #       join_table: :task_tags,
+        #       left_key: :task_id,
+        #       right_key: :tag_id,
+        #
+        #     def with_tags
+        #       association_join(:tags)
+        #     end
+        #   end
+        #
+        # @param [Symbol] name The name of the association
+        # @param [Hash] options The options hash
+        # @option options [Symbol] :join_table Name of the join table
+        # @option options [Hash] :left_key Name of the left join key
+        # @option options [Hash] :right_key Name of the right join key
+        # @option options [Hash] :on Additional conditions for join
+        # @option options [Hash] :conditions Additional conditions for WHERE
+        #
+        # @api public
         def many_to_many(name, options = {})
           associations << [__method__, name, { relation: name }.merge(options)]
         end
 
+        # Set up a many-to-one association
+        #
+        # @example
+        #   class Tasks < ROM::Relation[:sql]
+        #     many_to_one :users, key: :user_id
+        #
+        #     def with_users
+        #       association_join(:users)
+        #     end
+        #   end
+        #
+        # @param [Symbol] name The name of the association
+        # @param [Hash] options The options hash
+        # @option options [Symbol] :join_table Name of the join table
+        # @option options [Hash] :key Name of the join key
+        # @option options [Hash] :on Additional conditions for join
+        # @option options [Hash] :conditions Additional conditions for WHERE
+        #
+        # @api public
         def many_to_one(name, options = {})
           relation_name = Inflector.pluralize(name).to_sym
           new_options = options.merge(relation: relation_name)
           associations << [__method__, name, new_options]
         end
 
+        # Finalize the relation by setting up its associations (if any)
+        #
+        # @api private
         def finalize(relations, relation)
           model.set_dataset(relation.dataset)
           model.dataset.naked!

data/lib/rom/sql/repository.rb

@@ -6,6 +6,15 @@ require 'rom/sql/commands'
 
 module ROM
   module SQL
+    # SQL repository
+    #
+    # @example
+    #   db = Sequel.connect(:sqlite)
+    #   repository = ROM::SQL::Repository.new(db)
+    #
+    #   users = repository.dataset(:users)
+    #
+    # @api public
     class Repository < ROM::Repository
       include Options
       include Migration

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '0.4.3'.freeze
+    VERSION = '0.5.0'.freeze
   end
 end

data/spec/integration/commands/create_spec.rb

@@ -5,6 +5,7 @@ describe 'Commands / Create' do
   include_context 'database setup'
 
   subject(:users) { rom.commands.users }
+  subject(:tasks) { rom.commands.tasks }
 
   before do
     class Params
@@ -33,7 +34,12 @@ describe 'Commands / Create' do
       end
     end
 
+    setup.commands(:tasks) do
+      define(:create)
+    end
+
     setup.relation(:users)
+    setup.relation(:tasks)
   end
 
   context '#transaction' do
@@ -92,18 +98,19 @@ describe 'Commands / Create' do
 
     it 'creates nothing if constraint error was raised' do
       expect {
-        passed = false
-
-        result = users.create.transaction {
-          users.create.call(name: 'Jane')
-          users.create.call(name: 'Jane')
-        } >-> value {
-          passed = true
-        }
+        begin
+          passed = false
 
-        expect(result.value).to be(nil)
-        expect(result.error).to_not be(nil)
-        expect(passed).to be(false)
+          users.create.transaction {
+            users.create.call(name: 'Jane')
+            users.create.call(name: 'Jane')
+          } >-> value {
+            passed = true
+          }
+        rescue => error
+          expect(error).to be_instance_of(ROM::SQL::UniqueConstraintError)
+          expect(passed).to be(false)
+        end
       }.to_not change { rom.relations.users.count }
     end
 
@@ -138,30 +145,97 @@ describe 'Commands / Create' do
     ])
   end
 
-  it 'handles not-null constraint violation error' do
-    result = users.try { users.create.call(name: nil) }
+  it 're-raises not-null constraint violation error' do
+    expect {
+      users.try { users.create.call(name: nil) }
+    }.to raise_error(ROM::SQL::NotNullConstraintError, /not-null/)
+  end
 
-    expect(result.error).to be_instance_of(ROM::SQL::ConstraintError)
-    expect(result.error.message).to match(/not-null/)
+  it 're-raises uniqueness constraint violation error' do
+    expect {
+      users.try {
+        users.create.call(name: 'Jane')
+      } >-> user {
+        users.try { users.create.call(name: user[:name]) }
+      }
+    }.to raise_error(ROM::SQL::UniqueConstraintError, /unique/)
   end
 
-  it 'handles uniqueness constraint violation error' do
-    result = users.try {
-      users.create.call(name: 'Jane')
-    } >-> user {
-      users.try { users.create.call(name: user[:name]) }
-    }
+  it 're-raises check constraint violation error' do
+    expect {
+      users.try {
+        users.create.call(name: 'J')
+      }
+    }.to raise_error(ROM::SQL::CheckConstraintError, /name/)
+  end
 
-    expect(result.error).to be_instance_of(ROM::SQL::ConstraintError)
-    expect(result.error.message).to match(/unique/)
+  it 're-raises fk constraint violation error' do
+    expect {
+      tasks.try {
+        tasks.create.call(user_id: 918273645)
+      }
+    }.to raise_error(ROM::SQL::ForeignKeyConstraintError, /user_id/)
+  end
+
+  it 're-raises database errors' do
+    expect {
+      Params.attribute :bogus_field
+      users.try { users.create.call(name: 'some name', bogus_field: 23) }
+    }.to raise_error(ROM::SQL::DatabaseError)
   end
 
-  it 'handles database errors' do
-    Params.attribute :bogus_field
+  describe '.associates' do
+    it 'sets foreign key prior execution for many tuples' do
+      setup.commands(:tasks) do
+        define(:create) do
+          associates :user, key: [:user_id, :id]
+        end
+      end
+
+      create_user = rom.command(:users).create.with(name: 'Jade')
+
+      create_task = rom.command(:tasks).create.with([
+        { title: 'Task one' }, { title: 'Task two' }
+      ])
+
+      command = create_user >> create_task
+
+      result = command.call
+
+      expect(result).to match_array([
+        { id: 1, user_id: 1, title: 'Task one' },
+        { id: 2, user_id: 1, title: 'Task two' }
+      ])
+    end
+
+    it 'sets foreign key prior execution for one tuple' do
+      setup.commands(:tasks) do
+        define(:create) do
+          result :one
+          associates :user, key: [:user_id, :id]
+        end
+      end
+
+      create_user = rom.command(:users).create.with(name: 'Jade')
+      create_task = rom.command(:tasks).create.with(title: 'Task one')
+
+      command = create_user >> create_task
 
-    result = users.try { users.create.call(name: 'some name', bogus_field: 23) }
+      result = command.call
 
-    expect(result.error).to be_instance_of(ROM::SQL::DatabaseError)
-    expect(result.error.original_exception).to be_instance_of(Sequel::DatabaseError)
+      expect(result).to match_array(id: 1, user_id: 1, title: 'Task one')
+    end
+
+    it 'raises when already defined' do
+      expect {
+        setup.commands(:tasks) do
+          define(:create) do
+            result :one
+            associates :user, key: [:user_id, :id]
+            associates :user, key: [:user_id, :id]
+          end
+        end
+      }.to raise_error(ArgumentError, /user/)
+    end
   end
 end

data/spec/integration/commands/delete_spec.rb

@@ -53,15 +53,15 @@ describe 'Commands / Delete' do
     expect(result.value).to eql(id: 2, name: 'Jane')
   end
 
-  it 'handles database errors' do
+  it 're-raises database error' do
     command = users.delete.by_name('Jane')
 
-    expect(command.relation).to receive(:delete).and_raise(Sequel::DatabaseError)
+    expect(command.relation).to receive(:delete).and_raise(
+      Sequel::DatabaseError, 'totally wrong'
+    )
 
-    result = users.try { command.call }
-
-    expect(result.value).to be(nil)
-    expect(result.error).to be_a(ROM::SQL::DatabaseError)
-    expect(result.error.original_exception).to be_a(Sequel::DatabaseError)
+    expect {
+      users.try { command.call }
+    }.to raise_error(ROM::SQL::DatabaseError, /totally wrong/)
   end
 end

data/spec/integration/commands/update_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
+require 'anima'
 
 describe 'Commands / Update' do
   include_context 'database setup'
 
-  subject(:users) { rom.commands.users }
+  subject(:users) { rom.command(:users) }
 
   let(:relation) { rom.relations.users }
   let(:piotr) { relation.by_name('Piotr').first }
@@ -24,13 +25,21 @@ describe 'Commands / Update' do
       define(:update)
     end
 
+    User = Class.new { include Anima.new(:id, :name) }
+
+    setup.mappers do
+      register :users, entity: -> tuples { tuples.map { |tuple| User.new(tuple) } }
+    end
+
     relation.insert(name: 'Piotr')
   end
 
+  after { Object.send(:remove_const, :User) }
+
   context '#transaction' do
     it 'update record if there was no errors' do
       result = users.update.transaction do
-        users.update.by_id(piotr[:id]).set(peter)
+        users.update.by_id(piotr[:id]).call(peter)
       end
 
       expect(result.value).to eq([{ id: 1, name: 'Peter' }])
@@ -38,7 +47,7 @@ describe 'Commands / Update' do
 
     it 'updates nothing if error was raised' do
       users.update.transaction do
-        users.update.by_id(piotr[:id]).set(peter)
+        users.update.by_id(piotr[:id]).call(peter)
         raise ROM::SQL::Rollback
       end
 
@@ -48,7 +57,7 @@ describe 'Commands / Update' do
 
   it 'updates everything when there is no original tuple' do
     result = users.try do
-      users.update.by_id(piotr[:id]).set(peter)
+      users.update.by_id(piotr[:id]).call(peter)
     end
 
     expect(result.value.to_a).to match_array([{ id: 1, name: 'Peter' }])
@@ -56,10 +65,10 @@ describe 'Commands / Update' do
 
   it 'updates when attributes changed' do
     result = users.try do
-      users.update.by_id(piotr[:id]).change(piotr).to(peter)
+      users.as(:entity).update.by_id(piotr[:id]).change(User.new(piotr)).call(peter)
     end
 
-    expect(result.value.to_a).to match_array([{ id: 1, name: 'Peter' }])
+    expect(result.value.to_a).to match_array([User.new(id: 1, name: 'Peter')])
   end
 
   it 'does not update when attributes did not change' do
@@ -69,19 +78,15 @@ describe 'Commands / Update' do
     expect(piotr_rel).not_to receive(:update)
 
     result = users.try do
-      users.update.by_id(piotr[:id]).change(piotr).to(name: piotr[:name])
+      users.update.by_id(piotr[:id]).change(piotr).call(name: piotr[:name])
     end
 
     expect(result.value.to_a).to be_empty
   end
 
-  it 'handles database errors' do
-    result = users.try do
-      users.update.by_id(piotr[:id]).set(bogus_field: '#trollface')
-    end
-
-    expect(result.value).to be(nil)
-    expect(result.error).to be_a(ROM::SQL::DatabaseError)
-    expect(result.error.original_exception).to be_a(Sequel::DatabaseError)
+  it 're-reaises database errors' do
+    expect {
+      users.try { users.update.by_id(piotr[:id]).call(bogus_field: '#trollface') }
+    }.to raise_error(ROM::SQL::DatabaseError, /bogus_field/)
   end
 end

data/spec/shared/database_setup.rb

@@ -7,7 +7,7 @@ shared_context 'database setup' do
   let(:setup) { ROM.setup(:sql, conn) }
 
   def drop_tables
-    [:users, :tasks, :tags, :task_tags, :rabbits, :carrots, :schema_migrations].each do |name|
+    [:tasks, :users, :tags, :task_tags, :rabbits, :carrots, :schema_migrations].each do |name|
       conn.drop_table?(name)
     end
   end
@@ -21,11 +21,12 @@ shared_context 'database setup' do
       primary_key :id
       String :name, null: false
       index :name, unique: true
+      check { char_length(name) > 2 }
     end
 
     conn.create_table :tasks do
       primary_key :id
-      Integer :user_id
+      foreign_key :user_id, :users
       String :title
     end
 

data/spec/unit/many_to_one_spec.rb

@@ -3,9 +3,14 @@ require 'spec_helper'
 describe 'Defining many-to-one association' do
   include_context 'users and tasks'
 
+  before do
+    conn[:users].insert id: 2, name: 'Jane'
+    conn[:tasks].insert id: 2, user_id: 2, title: 'Task one'
+  end
+
   it 'extends relation with association methods' do
     setup.relation(:tasks) do
-      many_to_one :users, key: :user_id
+      many_to_one :users, key: :user_id, on: { name: 'Piotr' }
 
       def all
         select(:id, :title)

data/spec/unit/one_to_many_spec.rb

@@ -4,6 +4,9 @@ describe 'Defining one-to-many association' do
   include_context 'users and tasks'
 
   before do
+    conn[:users].insert id: 2, name: 'Jane'
+    conn[:tasks].insert id: 2, user_id: 2, title: 'Task one'
+
     setup.mappers do
       define(:users)
 
@@ -15,7 +18,7 @@ describe 'Defining one-to-many association' do
 
   it 'extends relation with association methods' do
     setup.relation(:users) do
-      one_to_many :tasks, key: :user_id
+      one_to_many :tasks, key: :user_id, on: { title: 'Finish ROM' }
 
       def by_name(name)
         where(name: name)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-sql
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-17 00:00:00.000000000 Z
+date: 2015-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -123,6 +123,7 @@ files:
 - lib/rom/sql/migration.rb
 - lib/rom/sql/migration/migrator.rb
 - lib/rom/sql/migration/template.rb
+- lib/rom/sql/plugin/associates.rb
 - lib/rom/sql/plugin/pagination.rb
 - lib/rom/sql/rake_task.rb
 - lib/rom/sql/relation.rb