rom-sql 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf05af538889499fb9fc1d4cb73ca842fae74482
-  data.tar.gz: '07441291fd839e047161b70cb9f20c88ebb240f9'
+  metadata.gz: ef99832857b3fd2134904b5c5cd99d33ad1665d8
+  data.tar.gz: 5a08cac386afc1d218d51a19d5d2a2167cb617d7
 SHA512:
-  metadata.gz: 447330e1514ca0aea9127434f02f2a81792e7702155f29c9a6c534938f1f88209ebc31328ef23cd7b368972854cb9e245916162ac05c981e59533c111c59ea54
-  data.tar.gz: 35a04cc320ec2d246c58fddb5b95aeb3787af7f055f27395596d84cd56013572999648e514d9beeafc15b9f87d879cf29753f3cd3715a8df5e05fe44d2dc061a
+  metadata.gz: 712552863d0d9a5cb8c4ce14557ed8705bc274bddff9c9c3b613379a93f470aac04fa5eddce7d133ad1ffe9bd024d05bb08cd052babf7a158cf0da320cbf55d3
+  data.tar.gz: a0baf07fda4b9eb66fa0e296a39e2f1d7ed641db3fe3f9feaacf4d2ad8a2b587902c4f335115fa3edd662c5e0aca818bc3140528591a2eeb9b12b2e602bfa3a1

data/.codeclimate.yml

@@ -0,0 +1,15 @@
+engines:
+ duplication:
+  enabled: true
+  config:
+    languages:
+      ruby:
+        mass_threshold: 25
+ rubocop:
+  enabled: true
+
+ratings:
+ paths:
+ - "**.rb"
+
+exclude_paths:

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## v1.2.0 2017-03-07
+
+### Added
+
+* Support for configuring multiple associations for a command (solnic)
+* Support for passing parent tuple(s) as `parent` option in `Command#with_association` (solnic)
+* Support for join using assocation name (flash-gordon)
+
+[Compare v1.1.2...v1.2.0](https://github.com/rom-rb/rom-sql/compare/v1.1.2...v1.2.0)
+
 ## v1.1.2 2017-03-02
 
 ### Fixed

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

@@ -20,6 +20,34 @@ module ROM
           end
         end
 
+        class AssociateOptions
+          attr_reader :name, :assoc, :opts
+
+          def initialize(name, relation, opts)
+            @name = name
+            @opts = { assoc: name, keys: opts[:key] }
+
+            relation.associations.try(name) do |assoc|
+              @assoc = assoc
+              @opts.update(assoc: assoc, keys: assoc.join_keys(relation.__registry__))
+            end
+
+            @opts.update(parent: opts[:parent]) if opts[:parent]
+          end
+
+          def after?
+            assoc.is_a?(Association::ManyToMany)
+          end
+
+          def ensure_valid(command)
+            raise MissingJoinKeysError.new(command, name) unless opts[:keys]
+          end
+
+          def to_hash
+            { associate: opts }
+          end
+        end
+
         # @api private
         def self.included(klass)
           klass.class_eval do
@@ -35,6 +63,62 @@ module ROM
           super
         end
 
+        module ClassMethods
+          # @see ROM::Command::ClassInterface.build
+          #
+          # @api public
+          def build(relation, options = EMPTY_HASH)
+            command = super
+
+            configured_assocs = command.configured_associations
+
+            associate_options = command.associations.map { |(name, opts)|
+              next if configured_assocs.include?(name)
+              AssociateOptions.new(name, relation, opts)
+            }.compact
+
+            associate_options.each { |opts| opts.ensure_valid(self) }
+
+            before_hooks = associate_options.reject(&:after?).map(&:to_hash)
+            after_hooks = associate_options.select(&:after?).map(&:to_hash)
+
+            command.
+              with_opts(configured_associations: configured_assocs + associate_options.map(&:name)).
+              before(*before_hooks).
+              after(*after_hooks)
+          end
+
+          # Set command to associate tuples with a parent tuple using provided keys
+          #
+          # @example
+          #   class CreateTask < ROM::Commands::Create[:sql]
+          #     relation :tasks
+          #     associates :user, key: [: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 = EMPTY_HASH)
+            if associations.key?(name)
+              raise ArgumentError,
+                    "#{name} association is already defined for #{self.class}"
+            end
+
+            associations(associations.merge(name => options))
+          end
+        end
+
         module InstanceMethods
           # Set fk on tuples from parent tuple
           #
@@ -44,7 +128,7 @@ module ROM
           # @return [Array<Hash>]
           #
           # @api public
-          def associate(tuples, parent, assoc:, keys:)
+          def associate(tuples, curried_parent = nil, assoc:, keys:, parent: curried_parent)
             result_type = result
 
             output_tuples =
@@ -90,97 +174,11 @@ module ROM
             )
           end
 
-          def associations_configured?
-            if configured_associations.empty?
-              false
-            else
-              configured_associations.all? { |name| associations.key?(name) }
-            end
-          end
-
           # @api private
           def __registry__
             relation.__registry__
           end
         end
-
-        module ClassMethods
-          # @see ROM::Command::ClassInterface.build
-          #
-          # @api public
-          def build(relation, options = EMPTY_HASH)
-            command = super
-
-            if command.associations_configured?
-              return command
-            end
-
-            associations = command.associations
-            assoc_names = []
-
-            before_hooks = associations.each_with_object([]) do |(name, opts), acc|
-              relation.associations.try(name) do |assoc|
-                unless assoc.is_a?(Association::ManyToMany)
-                  acc << { associate: { assoc: assoc, keys: assoc.join_keys(relation.__registry__) } }
-                else
-                  true
-                end
-              end or acc << { associate: { assoc: name, keys: opts[:key] } }
-
-              assoc_names << name
-            end
-
-            after_hooks = associations.each_with_object([]) do |(name, opts), acc|
-              next unless relation.associations.key?(name)
-
-              assoc = relation.associations[name]
-
-              if assoc.is_a?(Association::ManyToMany)
-                acc << { associate: { assoc: assoc, keys: assoc.join_keys(relation.__registry__) } }
-                assoc_names << name
-              end
-            end
-
-            [*before_hooks, *after_hooks].
-              map { |hook| hook[:associate] }.
-              each { |conf| raise MissingJoinKeysError.new(self, conf[:assoc]) unless conf[:keys] }
-
-            command.
-              with_opts(configured_associations: assoc_names).
-              before(*before_hooks).
-              after(*after_hooks)
-          end
-
-          # Set command to associate tuples with a parent tuple using provided keys
-          #
-          # @example
-          #   class CreateTask < ROM::Commands::Create[:sql]
-          #     relation :tasks
-          #     associates :user, key: [: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 = EMPTY_HASH)
-            if associations.key?(name)
-              raise ArgumentError,
-                    "#{name} association is already defined for #{self.class}"
-            end
-
-            associations(associations.merge(name => options))
-          end
-        end
       end
     end
   end

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

@@ -811,7 +811,12 @@ module ROM
         def __join__(type, other, join_cond = EMPTY_HASH, opts = EMPTY_HASH, &block)
           case other
           when Symbol, Association::Name
-            new(dataset.__send__(type, other.to_sym, join_cond, opts, &block))
+            if join_cond.empty?
+              assoc = associations[other]
+              assoc.join(__registry__, type, self, __registry__[assoc.target.relation])
+            else
+              new(dataset.__send__(type, other.to_sym, join_cond, opts, &block))
+            end
           when Relation
             associations[other.name.dataset].join(__registry__, type, self, other)
           else

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '1.1.2'.freeze
+    VERSION = '1.2.0'.freeze
   end
 end

data/spec/integration/plugins/associates_spec.rb

@@ -38,6 +38,21 @@ RSpec.describe 'Plugins / :associates', seeds: false do
           expect(command.call(task, user)).
             to eql(id: 1, title: 'Task one', user_id: user[:id])
         end
+
+        it 'allows passing a parent explicitly' do
+          command = tasks[:create].with_association(:user, key: %i[user_id id], parent: user)
+
+          expect(command.call(task)).
+            to eql(id: 1, title: 'Task one', user_id: user[:id])
+        end
+
+        it 'allows setting up multiple associations' do
+          command = tasks[:create].
+                      with_association(:user, key: %i[user_id id], parent: user).
+                      with_association(:other, key: %i[other_id id])
+
+          expect(command.configured_associations).to eql(%i[user other])
+        end
       end
 
       shared_context 'automatic FK setting' do

data/spec/unit/relation/inner_join_spec.rb

@@ -3,6 +3,7 @@ RSpec.describe ROM::Relation, '#inner_join' do
 
   let(:tasks) { relations[:tasks] }
   let(:tags) { relations[:tags] }
+  let(:puzzles) { relations[:puzzles] }
 
   include_context 'users and tasks'
 
@@ -39,9 +40,22 @@ RSpec.describe ROM::Relation, '#inner_join' do
 
     context 'with associations' do
       before do
+        inferrable_relations.concat %i(puzzles)
+      end
+
+      before do
+        conn.create_table(:puzzles) do
+          primary_key :id
+          foreign_key :author_id, :users, null: false
+          column :text, String, null: false
+        end
+
         conf.relation(:users) do
           schema(infer: true) do
-            associations { has_many :tasks }
+            associations do
+              has_many :tasks
+              has_many :tasks, as: :todos, relation: :tasks
+            end
           end
         end
 
@@ -64,7 +78,16 @@ RSpec.describe ROM::Relation, '#inner_join' do
           end
         end
 
+        conf.relation(:puzzles) do
+          schema(infer: true) do
+            associations do
+              belongs_to :users, as: :author
+            end
+          end
+        end
+
         relation.insert id: 3, name: 'Jade'
+        puzzles.insert id: 1, author_id: 1, text: 'solved by Jane'
       end
 
       it 'joins relation with join keys inferred' do
@@ -85,6 +108,39 @@ RSpec.describe ROM::Relation, '#inner_join' do
 
         expect(result.to_a).to eql([{ id: 1, user_id: 2, title: "Joe's task" }])
       end
+
+      it 'joins by association name if no condition provided' do
+        result = relation.
+                   inner_join(:tasks).
+                   select(:name, tasks[:title])
+
+        expect(result.schema.map(&:name)).to eql(%i[name title])
+
+        expect(result.to_a).to eql([
+                                     { name: 'Jane', title: "Jane's task" },
+                                     { name: 'Joe', title: "Joe's task" }
+                                   ])
+      end
+
+      it 'joins if association name differs from relation name' do
+        result = relation.
+                   inner_join(:todos).
+                   select(:name, tasks[:title])
+
+        expect(result.schema.map(&:name)).to eql(%i[name title])
+
+        expect(result.to_a).to eql([
+                                     { name: 'Jane', title: "Jane's task" },
+                                     { name: 'Joe', title: "Joe's task" }
+                                   ])
+      end
+
+      it 'joins by relation if association name differs from relation name' do
+        pending 'waits for support for joins by aliased relation'
+        result = puzzles.inner_join(users).select(:name, puzzles[:text])
+
+        expect(result.to_a).to eql([ name: 'Jane', title: "Jane's task" ])
+      end
     end
 
     it 'raises error when column names are ambiguous' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-sql
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-02 00:00:00.000000000 Z
+date: 2017-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -141,6 +141,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -345,7 +346,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.9
 signing_key: 
 specification_version: 4
 summary: SQL databases support for ROM