rom-sql 3.6.5 → 3.7.0

data/lib/rom/sql/migration/runner.rb

@@ -13,7 +13,7 @@ module ROM
 
         def call(changes)
           changes.each { |diff| apply_schema(diff) }
-          changes.each { |diff| apply_constraints(diff) }
+          changes.each { |diff| apply_constraints(diff) } # rubocop:disable Style/CombinableLoops
 
           self
         end
@@ -54,6 +54,7 @@ module ROM
           end
         end
 
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def alter_table(diff)
           return if diff.meta?
 
@@ -68,9 +69,8 @@ module ROM
                 when SchemaDiff::AttributeChanged
                   if attribute.type_changed?
                     from, to = attribute.current.unwrap, attribute.target.unwrap
-                    raise UnsupportedConversion.new(
-                      "Don't know how to convert #{from.inspect} to #{to.inspect}"
-                    )
+                    raise UnsupportedConversion,
+                          "Don't know how to convert #{from.inspect} to #{to.inspect}"
                   end
 
                   if attribute.nullability_changed?
@@ -94,6 +94,7 @@ module ROM
             end
           end
         end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def alter_foreign_keys(diff, foreign_key_changes)
           return if foreign_key_changes.empty?

data/lib/rom/sql/migration/schema_diff.rb

@@ -46,7 +46,6 @@ module ROM
         end
 
         class TableAltered < TableDiff
-
           option :attribute_changes, default: -> { EMPTY_ARRAY }
 
           option :index_changes, default: -> { EMPTY_ARRAY }
@@ -133,20 +132,22 @@ module ROM
         end
 
         class IndexAdded < IndexDiff
+          # rubocop:disable Metrics/AbcSize
           def options
             options = {}
-            options[:name] = index.name if !index.name.nil?
+            options[:name] = index.name unless index.name.nil?
             options[:unique] = true if index.unique?
-            options[:type] = index.type if !index.type.nil?
-            options[:where] = index.predicate if !index.predicate.nil?
+            options[:type] = index.type unless index.type.nil?
+            options[:where] = index.predicate unless index.predicate.nil?
             options
           end
+          # rubocop:enable Metrics/AbcSize
         end
 
         class IndexRemoved < IndexDiff
           def options
             options = {}
-            options[:name] = index.name if !index.name.nil?
+            options[:name] = index.name unless index.name.nil?
             options
           end
         end
@@ -177,6 +178,7 @@ module ROM
         class ForeignKeyRemoved < ForeignKeyDiff
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/MethodLength
         def call(current, target)
           if current.empty?
             TableCreated.new(
@@ -203,21 +205,23 @@ module ROM
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/MethodLength
 
+        # rubocop:disable Style/MultilineBlockChain
         def compare_attributes(current, target)
           changed_attributes = target.select { |name, attr|
             current.key?(name) && !attributes_equal?(current[name], attr)
-          }.map { |name, target_attr|
-            [name, [target_attr, current[name]]]
-          }.to_h
-          added_attributes = target.select { |name, _| !current.key?(name) }
-          removed_attributes = current.select { |name, _| !target.key?(name) }
+          }.to_h { |name, target_attr| [name, [target_attr, current[name]]] }
+          added_attributes = target.reject { |name, _| current.key?(name) }
+          removed_attributes = current.reject { |name, _| target.key?(name) }
 
           map_attributes(removed_attributes, AttributeRemoved) +
             map_attributes(added_attributes, AttributeAdded) +
             map_attributes(changed_attributes, AttributeChanged)
         end
+        # rubocop:enable Style/MultilineBlockChain
 
+        # rubocop:disable Metrics/AbcSize
         def compare_indexes(current, target)
           added_indexes = target.indexes.reject { |idx|
             current.indexes.any? { |curr_idx| curr_idx.attributes == idx.attributes }
@@ -229,6 +233,7 @@ module ROM
           removed_indexes.map { |idx| IndexRemoved.new(idx) } +
             added_indexes.map { |idx| IndexAdded.new(idx) }
         end
+        # rubocop:enable Metrics/AbcSize
 
         def compare_foreign_key_constraints(current, target)
           target_fks = target.foreign_keys

data/lib/rom/sql/migration/writer.rb

@@ -7,8 +7,8 @@ module ROM
     module Migration
       # @api private
       class Writer
-        MIGRATION_BEGIN = "ROM::SQL.migration do\n  change do".freeze
-        MIGRATION_END = "\n  end\nend\n".freeze
+        MIGRATION_BEGIN = "ROM::SQL.migration do\n  change do"
+        MIGRATION_END = "\n  end\nend\n"
 
         attr_reader :yield_migration
 
@@ -36,11 +36,11 @@ module ROM
             buffer << indent << op.to_s << ' '
             write_arguments(buffer, args)
 
-            if !nested.empty?
-              buffer << ' do'
-              write(nested, buffer, indent + '  ')
-              buffer << indent << 'end'
-            end
+            next if nested.empty?
+
+            buffer << ' do'
+            write(nested, buffer, "#{indent}  ")
+            buffer << indent << 'end'
           end
         end
 
@@ -61,7 +61,7 @@ module ROM
           create_or_alter, args = op
           table_name = args[0]
 
-          "#{create_or_alter.to_s.sub('_table', '')}_#{table_name}"
+          "#{create_or_alter.to_s.sub("_table", "")}_#{table_name}"
         end
       end
     end

data/lib/rom/sql/migration.rb

@@ -54,12 +54,12 @@ module ROM
       #   @param [Symbol] gateway The gateway name, :default by default
       #
       # @api public
-      def migration(*args, &block)
+      def migration(*args, &)
         if args.any?
           container, gateway, * = args
-          with_gateway(container.gateways[gateway || :default]) { migration(&block) }
+          with_gateway(container.gateways[gateway || :default]) { migration(&) }
         else
-          current_gateway.migration(&block)
+          current_gateway.migration(&)
         end
       end
 
@@ -121,8 +121,8 @@ module ROM
       # @see ROM::SQL.migration
       #
       # @api public
-      def migration(&block)
-        migrator.migration(&block)
+      def migration(&)
+        migrator.migration(&)
       end
 
       # Run migrations

data/lib/rom/sql/order_dsl.rb

@@ -8,12 +8,16 @@ module ROM
     class OrderDSL < DSL
       private
 
+      def respond_to_missing?(_meth, _include_private = false)
+        true
+      end
+
       # @api private
-      def method_missing(meth, *args, &block)
+      def method_missing(meth, ...)
         if schema.key?(meth)
           schema[meth]
         else
-          ::Sequel::VIRTUAL_ROW.__send__(meth.to_s.upcase, *args, &block)
+          ::Sequel::VIRTUAL_ROW.__send__(meth.to_s.upcase, ...)
         end
       end
     end

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

@@ -10,7 +10,11 @@ module ROM
       # @api private
       module Associates
         class AssociateOptions
-          attr_reader :name, :assoc, :opts
+          attr_reader :name
+
+          attr_reader :assoc
+
+          attr_reader :opts
 
           # @api private
           def initialize(name, relation, opts)
@@ -37,7 +41,7 @@ module ROM
 
             defines :associations
 
-            associations Hash.new
+            associations({})
 
             option :associations, default: -> { self.class.associations }
             option :configured_associations, default: -> { EMPTY_ARRAY }
@@ -57,16 +61,17 @@ module ROM
 
             associate_options = command.associations.map { |(name, opts)|
               next if configured_assocs.include?(name)
+
               AssociateOptions.new(name, relation, opts)
             }.compact
 
             before_hooks = associate_options.reject(&:after?).map(&:to_hash)
             after_hooks = associate_options.select(&:after?).map(&:to_hash)
 
-            command.
-              with(configured_associations: configured_assocs + associate_options.map(&:name)).
-              before(*before_hooks).
-              after(*after_hooks)
+            command
+              .with(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
@@ -109,7 +114,15 @@ module ROM
           # @return [Array<Hash>]
           #
           # @api public
-          def associate(tuples, curried_parent = nil, assoc:, keys:, parent: curried_parent)
+          #
+          # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize
+          def associate(
+            tuples,
+            curried_parent = nil,
+            assoc:,
+            keys:, # rubocop:disable Lint/UnusedMethodArgument
+            parent: curried_parent
+          )
             result_type = result
 
             output_tuples =
@@ -137,6 +150,7 @@ module ROM
 
             result_type == :one ? output_tuples[0] : output_tuples
           end
+          # rubocop:enable Metrics/PerceivedComplexity, Metrics/AbcSize
 
           # Return a new command with the provided association
           #

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

@@ -53,7 +53,7 @@ module ROM
           # @api public
           def prev_page
             num = current_page - 1
-            num if num > 0
+            num if num.positive?
           end
 
           # Return total number of tuples
@@ -100,7 +100,7 @@ module ROM
             per_page = per_page.to_i
 
             self.class.new(
-              dataset.offset((current_page-1)*per_page).limit(per_page),
+              dataset.offset((current_page - 1) * per_page).limit(per_page),
               current_page: current_page, per_page: per_page
             )
           end

data/lib/rom/sql/projection_dsl.rb

@@ -49,7 +49,7 @@ module ROM
       private
 
       # @api private
-      def method_missing(meth, *args, &block)
+      def method_missing(meth, *args, &)
         if schema.key?(meth)
           schema[meth]
         else

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

@@ -9,20 +9,22 @@ module ROM
       # Query API for SQL::Relation
       #
       # @api public
+      #
+      # rubocop:disable Metrics/ModuleLength
       module Reading
         # Row-level lock modes
-        ROW_LOCK_MODES = Hash.new({ update: "FOR UPDATE" }).update(
+        ROW_LOCK_MODES = Hash.new({ update: 'FOR UPDATE' }).update(
           # https://www.postgresql.org/docs/current/static/sql-select.html#SQL-FOR-UPDATE-SHARE
           postgres: {
-            update: 'FOR UPDATE'.freeze,
-            no_key_update: 'FOR NO KEY UPDATE'.freeze,
-            share: 'FOR SHARE'.freeze,
-            key_share: 'FOR KEY SHARE'.freeze
+            update: 'FOR UPDATE',
+            no_key_update: 'FOR NO KEY UPDATE',
+            share: 'FOR SHARE',
+            key_share: 'FOR KEY SHARE'
           },
           # https://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
           mysql: {
-            update: 'FOR UPDATE'.freeze,
-            share: 'LOCK IN SHARE MODE'.freeze
+            update: 'FOR UPDATE',
+            share: 'LOCK IN SHARE MODE'
           }
         ).freeze
 
@@ -140,11 +142,11 @@ module ROM
         #                     from tuples
         #
         # @api public
-        def map(key = nil, &block)
+        def map(key = nil, &)
           if key
-            dataset.map(key, &block)
+            dataset.map(key, &)
           else
-            dataset.map(&block)
+            dataset.map(&)
           end
         end
 
@@ -235,8 +237,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def select(*args, &block)
-          schema.project(*args, &block).(self)
+        def select(...)
+          schema.project(...).(self)
         end
         alias_method :project, :select
 
@@ -247,8 +249,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def select_append(*args, &block)
-          schema.merge(schema.canonical.project(*args, &block)).(self)
+        def select_append(...)
+          schema.merge(schema.canonical.project(...)).(self)
         end
 
         # Returns a copy of the relation with a SQL DISTINCT clause.
@@ -271,8 +273,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def distinct(*args, &block)
-          new(dataset.__send__(__method__, *args, &block))
+        def distinct(...)
+          new(dataset.__send__(__method__, ...))
         end
 
         # Returns a result of SQL SUM clause.
@@ -359,9 +361,9 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def where(*args, &block)
-          if block
-            where(*args).where(schema.canonical.restriction(&block))
+        def where(*args, &)
+          if block_given?
+            where(*args).where(schema.canonical.restriction(&))
           elsif args.size == 1 && args[0].is_a?(Hash)
             new(dataset.where(coerce_conditions(args[0])))
           elsif !args.empty?
@@ -381,8 +383,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def exclude(*args, &block)
-          new(dataset.__send__(__method__, *args, &block))
+        def exclude(...)
+          new(dataset.__send__(__method__, ...))
         end
 
         # Restrict a relation to match grouping criteria
@@ -418,9 +420,9 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def having(*args, &block)
-          if block
-            new(dataset.having(*args, *schema.canonical.restriction(&block)))
+        def having(*args, &)
+          if block_given?
+            new(dataset.having(*args, *schema.canonical.restriction(&)))
           else
             new(dataset.__send__(__method__, *args))
           end
@@ -473,11 +475,11 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def order(*args, &block)
-          if block
-            new(dataset.order(*args, *schema.canonical.order(&block)))
+        def order(*args, &)
+          if block_given?
+            new(dataset.order(*args, *schema.canonical.order(&)))
           else
-            new(dataset.__send__(__method__, *args, &block))
+            new(dataset.__send__(__method__, *args, &))
           end
         end
 
@@ -501,8 +503,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def reverse(*args, &block)
-          new(dataset.__send__(__method__, *args, &block))
+        def reverse(...)
+          new(dataset.__send__(__method__, ...))
         end
 
         # Limit a relation to a specific number of tuples
@@ -590,8 +592,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def join(*args, &block)
-          __join__(__method__, *args, &block)
+        def join(...)
+          __join__(__method__, ...)
         end
         alias_method :inner_join, :join
 
@@ -640,8 +642,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def left_join(*args, &block)
-          __join__(__method__, *args, &block)
+        def left_join(...)
+          __join__(__method__, ...)
         end
 
         # Join with another relation using RIGHT JOIN
@@ -689,8 +691,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def right_join(*args, &block)
-          __join__(__method__, *args, &block)
+        def right_join(...)
+          __join__(__method__, ...)
         end
 
         # Group by specific columns
@@ -722,12 +724,12 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def group(*args, &block)
-          if block
-            if args.size > 0
-              group(*args).group_append(&block)
+        def group(*args, &)
+          if block_given?
+            if args.size.positive?
+              group(*args).group_append(&)
             else
-              new(dataset.__send__(__method__, *schema.canonical.group(&block)))
+              new(dataset.__send__(__method__, *schema.canonical.group(&)))
             end
           else
             new(dataset.__send__(__method__, *schema.canonical.project(*args)))
@@ -761,12 +763,12 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def group_append(*args, &block)
-          if block
-            if args.size > 0
-              group_append(*args).group_append(&block)
+        def group_append(*args, &)
+          if block_given?
+            if args.size.positive?
+              group_append(*args).group_append(&)
             else
-              new(dataset.group_append(*schema.canonical.group(&block)))
+              new(dataset.group_append(*schema.canonical.group(&)))
             end
           else
             new(dataset.group_append(*args))
@@ -784,8 +786,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def group_and_count(*args, &block)
-          new(dataset.__send__(__method__, *args, &block))
+        def group_and_count(...)
+          new(dataset.__send__(__method__, ...))
         end
 
         # Select and group by specific columns
@@ -799,8 +801,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def select_group(*args, &block)
-          new_schema = schema.project(*args, &block)
+        def select_group(...)
+          new_schema = schema.project(...)
           new_schema.(self).group(*new_schema)
         end
 
@@ -813,14 +815,17 @@ module ROM
         # @param [Relation] relation Another relation
         #
         # @param [Hash] options Options for union
-        # @option options [Symbol] :alias Use the given value as the #from_self alias
-        # @option options [TrueClass, FalseClass] :all Set to true to use UNION ALL instead of UNION, so duplicate rows can occur
-        # @option options [TrueClass, FalseClass] :from_self Set to false to not wrap the returned dataset in a #from_self, use with care.
+        # @option options [Symbol] :alias
+        #         Use the given value as the #from_self alias
+        # @option options [true, false] :all
+        #         Set to true to use UNION ALL instead of UNION, so duplicate rows can occur
+        # @option options [true, false] :from_self
+        #         Set to false to not wrap the returned dataset in a #from_self, use with care.
         #
         # @returRelation]
         #
         # @api public
-        def union(relation, options = EMPTY_HASH, &block)
+        def union(relation, options = EMPTY_HASH, &)
           # We use the original relation name here if both relations have the
           # same name. This makes it so if the user at some point references
           # the relation directly by name later on things won't break in
@@ -830,7 +835,7 @@ module ROM
           opts = { alias: alias_name.to_sym, **options }
 
           new_schema = schema.qualified(opts[:alias])
-          new_schema.(new(dataset.__send__(__method__, relation.dataset, opts, &block)))
+          new_schema.(new(dataset.__send__(__method__, relation.dataset, opts, &)))
         end
 
         # Checks whether a relation has at least one tuple
@@ -848,8 +853,8 @@ module ROM
         # @return [TrueClass, FalseClass]
         #
         # @api public
-        def exist?(*args, &block)
-          !where(*args, &block).limit(1).count.zero?
+        def exist?(...)
+          !where(...).limit(1).count.zero?
         end
 
         # Return if a restricted relation has 0 tuples
@@ -905,12 +910,12 @@ module ROM
         #   @yieldparam relation [Array]
         #
         # @api public
-        def lock(**options, &block)
+        def lock(**options, &)
           clause = lock_clause(**options)
 
-          if block
+          if block_given?
             transaction do
-              block.call(dataset.lock_style(clause).to_a)
+              yield(dataset.lock_style(clause).to_a)
             end
           else
             new(dataset.lock_style(clause))
@@ -1050,7 +1055,7 @@ module ROM
           stmt << ' OF ' << Array(of).join(', ') if of
 
           if skip_locked
-            raise ArgumentError, 'SKIP LOCKED cannot be used with (NO)WAIT clause' if !wait.nil?
+            raise ArgumentError, 'SKIP LOCKED cannot be used with (NO)WAIT clause' unless wait.nil?
 
             stmt << ' SKIP LOCKED'
           else
@@ -1068,6 +1073,8 @@ module ROM
         # Apply input types to condition values
         #
         # @api private
+        #
+        # rubocop:disable Metrics/AbcSize
         def coerce_conditions(conditions)
           conditions.each_with_object({}) { |(k, v), h|
             if k.is_a?(Symbol) && schema.canonical.key?(k)
@@ -1080,25 +1087,28 @@ module ROM
             end
           }
         end
+        # rubocop:enable Metrics/AbcSize
 
         # Common join method used by other join methods
         #
         # @api private
-        def __join__(type, other, join_cond = EMPTY_HASH, opts = EMPTY_HASH, &block)
+        #
+        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity
+        def __join__(type, other, join_cond = EMPTY_HASH, opts = EMPTY_HASH, &)
           if other.is_a?(Symbol) || other.is_a?(ROM::Relation::Name)
-            if join_cond.equal?(EMPTY_HASH) && !block
+            if join_cond.equal?(EMPTY_HASH) && !block_given?
               assoc = associations[other]
               assoc.join(type, self)
-            elsif block
-              __join__(type, other, JoinDSL.new(schema).(&block), opts)
+            elsif block_given?
+              __join__(type, other, JoinDSL.new(schema).(&), opts)
             else
-              new(dataset.__send__(type, other.to_sym, join_cond, opts, &block))
+              new(dataset.__send__(type, other.to_sym, join_cond, opts, &))
             end
-          elsif other.is_a?(Sequel::SQL::AliasedExpression)
-            new(dataset.__send__(type, other, join_cond, opts, &block))
+          elsif other.is_a?(::Sequel::SQL::AliasedExpression)
+            new(dataset.__send__(type, other, join_cond, opts, &))
           elsif other.respond_to?(:name) && other.name.is_a?(Relation::Name)
-            if block
-              join_cond = JoinDSL.new(schema).(&block)
+            if block_given?
+              join_cond = JoinDSL.new(schema).(&)
 
               if other.name.aliaz
                 join_opts = { table_alias: other.name.aliaz }
@@ -1111,10 +1121,12 @@ module ROM
               associations[other.name.key].join(type, self, other)
             end
           else
-            raise ArgumentError, "+other+ must be either a symbol or a relation, #{other.class} given"
+            raise ArgumentError,
+                  "+other+ must be either a symbol or a relation, #{other.class} given"
           end
         end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/ModuleLength
     end
   end
 end