rom-sql 3.6.5 → 3.7.0

data/lib/rom/sql/extensions/postgres/types/ltree.rb

@@ -6,14 +6,14 @@ module ROM
   module SQL
     module Postgres
       # @api public
+      #
+      # rubocop:disable Metrics/ModuleLength
       module Types
         # @see https://www.postgresql.org/docs/current/static/ltree.html
 
         LTree = Type('ltree') do
           SQL::Types.define(ROM::Types::Values::TreePath) do
-            input do |label_path|
-              label_path.to_s
-            end
+            input(&:to_s)
 
             output do |label_path|
               ROM::Types::Values::TreePath.new(label_path.to_s) if label_path
@@ -41,8 +41,12 @@ module ROM
         #     #   Translates to the ? operator
         #     #
         #     #   @example
-        #     #     people.select(:name).where { ltree_tags.match_any(['Bottom', 'Bottom.Cities.*']) }
-        #     #     people.select(:name).where { ltree_tags.match_any('Bottom,Bottom.Cities.*') }
+        #     #     people.select(:name).where {
+        #     #       ltree_tags.match_any(['Bottom', 'Bottom.Cities.*'])
+        #     #     }
+        #     #     people.select(:name).where {
+        #     #       ltree_tags.match_any('Bottom,Bottom.Cities.*')
+        #     #     }
         #     #
         #     #   @param [Array,String] value
         #     #
@@ -69,7 +73,9 @@ module ROM
         #     #
         #     #   @example
         #     #     people.select(:name).where { ltree_tags.contain_descendant(['Bottom.Cities']) }
-        #     #     people.select(:name).where { ltree_tags.contain_descendant('Bottom.Cities, Bottom.Parks') }
+        #     #     people.select(:name).where {
+        #     #       ltree_tags.contain_descendant('Bottom.Cities, Bottom.Parks')
+        #     #     }
         #     #
         #     #   @param [Array<String>, String] value
         #     #
@@ -96,7 +102,9 @@ module ROM
         #     #
         #     #   @example
         #     #     people.select(:name).where { ltree_tags.contain_ascendant(['Bottom.Cities']) }
-        #     #     people.select(:name).where { ltree_tags.contain_ascendant('Bottom.Cities, Bottom.Parks') }
+        #     #     people.select(:name).where {
+        #     #       ltree_tags.contain_ascendant('Bottom.Cities, Bottom.Parks')
+        #     #     }
         #     #
         #     #   @param [Array<String>, String] value
         #     #
@@ -122,8 +130,12 @@ module ROM
         #     #   Translates to ||
         #     #
         #     #   @example
-        #     #     people.select { (ltree_tags + ROM::Types::Values::TreePath.new('Moscu')).as(:ltree_tags) }.where { name.is('Jade Doe') }
-        #     #     people.select { (ltree_tags + 'Moscu').as(:ltree_tags) }.where { name.is('Jade Doe') }
+        #     #     people.select {
+        #     #       (ltree_tags + ROM::Types::Values::TreePath.new('Moscu')).as(:ltree_tags)
+        #     #     }.where { name.is('Jade Doe') }
+        #     #     people.select {
+        #     #       (ltree_tags + 'Moscu').as(:ltree_tags)
+        #     #     }.where { name.is('Jade Doe') }
         #     #
         #     #   @param [LTree, String] keys
         #     #
@@ -149,7 +161,9 @@ module ROM
         #     #   Translates to @>
         #     #
         #     #   @example
-        #     #     people.select(:name).where { parents_tags.contain_ancestor('Top.Building.EmpireState.381')}
+        #     #     people.select(:name).where {
+        #     #       parents_tags.contain_ancestor('Top.Building.EmpireState.381')
+        #     #     }
         #     #
         #     #   @param [String] value
         #     #
@@ -162,7 +176,9 @@ module ROM
         #     #   Translates to <@
         #     #
         #     #   @example
-        #     #     people.select(:name).where { parents_tags.contain_descendant('Top.Building.EmpireState.381')}
+        #     #     people.select(:name).where {
+        #     #       parents_tags.contain_descendant('Top.Building.EmpireState.381')
+        #     #     }
         #     #
         #     #   @param [String] value
         #     #
@@ -175,7 +191,9 @@ module ROM
         #     #   Translates to ?@>
         #     #
         #     #   @example
-        #     #     people.select(:name).where { parents_tags.find_ancestor('Left.Parks').not(nil)}
+        #     #     people.select(:name).where {
+        #     #       parents_tags.find_ancestor('Left.Parks').not(nil)
+        #     #     }
         #     #
         #     #   @param [String] value
         #     #
@@ -188,7 +206,9 @@ module ROM
         #     #   Translates to ?<@
         #     #
         #     #   @example
-        #     #     people.select(:name).where { parents_tags.find_descendant('Left.Parks').not(nil)}
+        #     #     people.select(:name).where {
+        #     #       parents_tags.find_descendant('Left.Parks').not(nil)
+        #     #     }
         #     #
         #     #   @param [String] value
         #     #
@@ -201,7 +221,9 @@ module ROM
         #     #   Translates to ?~
         #     #
         #     #   @example
-        #     #     people.select(:name).where { parents_tags.match_any_lquery('Right.*').not(nil)}
+        #     #     people.select(:name).where {
+        #     #       parents_tags.match_any_lquery('Right.*').not(nil)
+        #     #     }
         #     #
         #     #   @param [String] value
         #     #
@@ -214,7 +236,9 @@ module ROM
         #     #   Translates to ?@
         #     #
         #     #   @example
-        #     #     people.select(:name).where { parents_tags.match_any_ltextquery('EmpireState').not(nil)}
+        #     #     people.select(:name).where {
+        #     #       parents_tags.match_any_ltextquery('EmpireState').not(nil)
+        #     #     }
         #     #
         #     #   @param [String] value
         #     #
@@ -234,12 +258,16 @@ module ROM
           MATCH_ANY_LTEXTQUERY = ['(', ' ?@ ', ')'].freeze
 
           def match(_type, expr, query)
-            Attribute[SQL::Types::Bool].meta(sql_expr: Sequel::SQL::BooleanExpression.new(:'~', expr, query))
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: ::Sequel::SQL::BooleanExpression.new(:~, expr, query)
+            )
           end
 
           def match_any(_type, expr, query)
             array = build_array_query(query)
-            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(MATCH_ANY, expr, array))
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: custom_operator_expr(MATCH_ANY, expr, array)
+            )
           end
 
           private
@@ -262,31 +290,57 @@ module ROM
           include LTreeMethods
 
           def contain_any_ltextquery(_type, expr, query)
-            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_LTEXTQUERY, expr, query))
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: custom_operator_expr(
+                LTreeMethods::MATCH_LTEXTQUERY, expr, query
+              )
+            )
           end
 
           def contain_ancestor(_type, expr, query)
-            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::ASCENDANT, expr, query))
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: custom_operator_expr(
+                LTreeMethods::ASCENDANT, expr, query
+              )
+            )
           end
 
           def contain_descendant(_type, expr, query)
-            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::DESCENDANT, expr, query))
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: custom_operator_expr(
+                LTreeMethods::DESCENDANT, expr, query
+              )
+            )
           end
 
           def find_ancestor(_type, expr, query)
-            Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::FIND_ASCENDANT, expr, query))
+            Attribute[LTree].meta(
+              sql_expr: custom_operator_expr(
+                LTreeMethods::FIND_ASCENDANT, expr, query
+              )
+            )
           end
 
           def find_descendant(_type, expr, query)
-            Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::FIND_DESCENDANT, expr, query))
+            Attribute[LTree].meta(
+              sql_expr: custom_operator_expr(
+                LTreeMethods::FIND_DESCENDANT, expr, query
+              )
+            )
           end
 
           def match_any_lquery(_type, expr, query)
-            Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_ANY_LQUERY, expr, query))
+            Attribute[LTree].meta(
+              sql_expr: custom_operator_expr(
+                LTreeMethods::MATCH_ANY_LQUERY, expr, query
+              )
+            )
           end
 
           def match_any_ltextquery(_type, expr, query)
-            Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_ANY_LTEXTQUERY, expr, query))
+            Attribute[LTree].meta(sql_expr: custom_operator_expr(
+              LTreeMethods::MATCH_ANY_LTEXTQUERY, expr, query
+            ))
           end
         end
 
@@ -294,38 +348,54 @@ module ROM
           include LTreeMethods
 
           def match_ltextquery(_type, expr, query)
-            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_LTEXTQUERY, expr, query))
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(
+              LTreeMethods::MATCH_LTEXTQUERY, expr, query
+            ))
           end
 
           def contain_descendant(_type, expr, query)
             array = build_array_query(query, 'ltree')
-            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::DESCENDANT, expr, array))
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(
+              LTreeMethods::DESCENDANT, expr, array
+            ))
           end
 
           def descendant(_type, expr, query)
-            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::DESCENDANT, expr, query))
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(
+              LTreeMethods::DESCENDANT, expr, query
+            ))
           end
 
           def contain_ascendant(_type, expr, query)
             array = build_array_query(query, 'ltree')
-            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::ASCENDANT, expr, array))
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(
+              LTreeMethods::ASCENDANT, expr, array
+            ))
           end
 
           def ascendant(_type, expr, query)
-            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::ASCENDANT, expr, query))
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(
+              LTreeMethods::ASCENDANT, expr, query
+            ))
           end
 
           def +(_type, expr, other)
-            other_value = case other
-                          when ROM::Types::Values::TreePath
-                            other
-                          else
-                            ROM::Types::Values::TreePath.new(other)
-                          end
-            Attribute[LTree].meta(sql_expr: Sequel::SQL::StringExpression.new(:'||', expr, other_value.to_s))
+            other_value =
+              case other
+              when ::ROM::Types::Values::TreePath
+                other
+              else
+                ::ROM::Types::Values::TreePath.new(other)
+              end
+            Attribute[LTree].meta(
+              sql_expr: ::Sequel::SQL::StringExpression.new(
+                :'||', expr, other_value.to_s
+              )
+            )
           end
         end
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rom/sql/extensions/postgres/types/range.rb

@@ -9,19 +9,16 @@ module ROM
     module Postgres
       module Values
         Range = ::Struct.new(:lower, :upper, :bounds) do
-          PAREN_LEFT  = '('.freeze
-          PAREN_RIGHT = ')'.freeze
-
           def initialize(lower, upper, bounds = :'[)')
             super
           end
 
           def exclude_begin?
-            bounds[0] == PAREN_LEFT
+            bounds[0] == '('
           end
 
           def exclude_end?
-            bounds[1] == PAREN_RIGHT
+            bounds[1] == ')'
           end
         end
       end
@@ -38,10 +35,10 @@ module ROM
           int8range: Sequel::Postgres::PGRange::Parser.new(
             'int8range', SQL::Types::Coercible::Integer
           ),
-          numrange:  Sequel::Postgres::PGRange::Parser.new(
+          numrange: Sequel::Postgres::PGRange::Parser.new(
             'numrange', SQL::Types::Coercible::Integer
           ),
-          tsrange:   Sequel::Postgres::PGRange::Parser.new(
+          tsrange: Sequel::Postgres::PGRange::Parser.new(
             'tsrange', ::Time.method(:parse)
           ),
           tstzrange: Sequel::Postgres::PGRange::Parser.new(
@@ -56,20 +53,21 @@ module ROM
         def self.range_read_type(name)
           SQL::Types.Constructor(Values::Range) do |value|
             pg_range =
-              if value.is_a?(Sequel::Postgres::PGRange)
+              if value.is_a?(::Sequel::Postgres::PGRange)
                 value
-              elsif value && value.respond_to?(:to_s)
+              elsif value && value.respond_to?(:to_s) # rubocop:disable Style/SafeNavigation
                 @range_parsers[name].(value.to_s)
-              else
+              else # rubocop:disable Lint/DuplicateBranch
                 value
               end
 
             Values::Range.new(
               pg_range.begin,
               pg_range.end,
-              [pg_range.exclude_begin? ? :'(' : :'[',
-               pg_range.exclude_end? ? :')' : :']']
-              .join('').to_sym
+              [
+                pg_range.exclude_begin? ? :'(' : :'[',
+                pg_range.exclude_end? ? :')' : :']'
+              ].join.to_sym
             )
           end
         end
@@ -78,11 +76,13 @@ module ROM
         def self.range(name, read_type)
           Type(name) do
             type = SQL::Types.Nominal(Values::Range).constructor do |range|
-              format('%s%s,%s%s',
-                     range.exclude_begin? ? :'(' : :'[',
-                     range.lower,
-                     range.upper,
-                     range.exclude_end? ? :')' : :']')
+              format(
+                '%<begin>s%<lower>s,%<upper>s%<end>s',
+                begin: range.exclude_begin? ? :'(' : :'[',
+                lower: range.lower,
+                upper: range.upper,
+                end: range.exclude_end? ? :')' : :']'
+              )
             end
 
             type.meta(read: read_type)

data/lib/rom/sql/extensions/rails_log_subscriber.rb

@@ -7,15 +7,15 @@ module ROM
     class RailsLogSubscriber < ActiveSupport::LogSubscriber
       as_version =
         begin
-          require "active_support/gem_version"
+          require 'active_support/gem_version'
           ActiveSupport.gem_version
         rescue LoadError
           nil
         end
 
       COLOR_OPTION =
-        if as_version && as_version >= Gem::Version.new("7.2")
-          {color: true}
+        if as_version && as_version >= ::Gem::Version.new('7.2')
+          { color: true }
         else
           true
         end
@@ -25,7 +25,7 @@ module ROM
 
         payload = event.payload
 
-        name = format('%s (%.1fms)', payload[:name], event.duration)
+        name = format('%<name>s (%<duration>.1fms)', name: payload[:name], duration: event.duration)
         sql  = payload[:sql].squeeze(' ')
         binds = payload[:binds].to_a.inspect if payload[:binds]
 

data/lib/rom/sql/function.rb

@@ -19,10 +19,10 @@ module ROM
           when :start then 'UNBOUNDED PRECEDING'
           when :end then 'UNBOUNDED FOLLOWING'
           else
-            if value > 0
-              "#{ value } FOLLOWING"
+            if value.positive?
+              "#{value} FOLLOWING"
             else
-              "#{ value.abs } PRECEDING"
+              "#{value.abs} PRECEDING"
             end
           end
         end
@@ -34,13 +34,14 @@ module ROM
       WINDOW_FRAMES = Hash.new do |cache, frame|
         type = frame.key?(:rows) ? 'ROWS' : 'RANGE'
         bounds = frame[:rows] || frame[:range]
-        cache[frame] = "#{ type } BETWEEN #{ frame_limit(bounds[0]) } AND #{ frame_limit(bounds[1])  }"
+        cache[frame] =
+          "#{type} BETWEEN #{frame_limit(bounds[0])} AND #{frame_limit(bounds[1])}"
       end
 
       WINDOW_FRAMES[nil] = nil
-      WINDOW_FRAMES[:all] = WINDOW_FRAMES[rows: [:start, :end]]
-      WINDOW_FRAMES[:rows] = WINDOW_FRAMES[rows: [:start, :current]]
-      WINDOW_FRAMES[{ range: :current }] = WINDOW_FRAMES[range: [:current, :current]]
+      WINDOW_FRAMES[:all] = WINDOW_FRAMES[rows: %i[start end]]
+      WINDOW_FRAMES[:rows] = WINDOW_FRAMES[rows: %i[start current]]
+      WINDOW_FRAMES[{ range: :current }] = WINDOW_FRAMES[range: %i[current current]]
 
       # Return a new attribute with an alias
       #
@@ -88,10 +89,10 @@ module ROM
       end
 
       # @api private
-      def new(&block)
+      def new(&)
         case func
         when ::Sequel::SQL::Function
-          meta(func: ::Sequel::SQL::Function.new!(func.name, func.args.map(&block), func.opts))
+          meta(func: ::Sequel::SQL::Function.new!(func.name, func.args.map(&), func.opts))
         else
           meta(func: func)
         end
@@ -125,7 +126,15 @@ module ROM
       #
       # @example
       #   users.select { [id, integer::row_number().over(partition: name, order: id).as(:row_no)] }
-      #   users.select { [id, integer::row_number().over(partition: [first_name, last_name], order: id).as(:row_no)] }
+      #   users.select {
+      #     [
+      #       id,
+      #       integer::row_number().over(
+      #         partition: [first_name, last_name],
+      #         order: id
+      #       ).as(:row_no)
+      #     ]
+      #   }
       #
       # @example frame variants
       #   # ROWS BETWEEN 3 PRECEDING AND CURRENT ROW
@@ -167,7 +176,8 @@ module ROM
       #   users.select { bool::cast(json_data.get_text('activated')).as(:activated) }
       #
       # @param [ROM::SQL::Attribute] expr Expression to be cast
-      # @param [String] db_type Target database type (usually can be inferred from the target data type)
+      # @param [String] db_type
+      #        Target database type (usually can be inferred from the target data type)
       #
       # @return [ROM::SQL::Attribute]
       #
@@ -211,10 +221,10 @@ module ROM
       # @return [SQL::Function]
       #
       # @api public
-      def filter(condition = Undefined, &block)
-        if block
-          conditions = schema.restriction(&block)
-          conditions = conditions & condition unless condition.equal?(Undefined)
+      def filter(condition = Undefined, &)
+        if block_given?
+          conditions = schema.restriction(&)
+          conditions &= condition unless condition.equal?(Undefined)
         else
           conditions = condition
         end
@@ -236,9 +246,9 @@ module ROM
       # @return [SQL::Function]
       #
       # @api public
-      def within_group(*args, &block)
-        if block
-          group = args + ::ROM::SQL::OrderDSL.new(schema).(&block)
+      def within_group(*args, &)
+        if block_given?
+          group = args + ::ROM::SQL::OrderDSL.new(schema).(&)
         else
           group = args
         end
@@ -258,6 +268,15 @@ module ROM
         meta[:func]
       end
 
+      # @api private
+      def respond_to_missing?(meth, _include_private = false)
+        if func
+          func.respond_to?(meth) || super
+        else
+          true
+        end
+      end
+
       # @api private
       def method_missing(meth, *args)
         if func

data/lib/rom/sql/gateway.rb

@@ -75,13 +75,14 @@ module ROM
       #
       # @return [SQL::Gateway]
       #
-      # @see https://github.com/jeremyevans/sequel/blob/master/doc/opening_databases.rdoc Sequel connection docs
+      # @see https://github.com/jeremyevans/sequel/blob/master/doc/opening_databases.rdoc
+      #      Sequel connection docs
       #
       # @api public
       def initialize(uri, options = EMPTY_HASH)
         @connection = connect(uri, options)
         load_extensions(Array(options[:extensions]))
-        Notifications.trigger("configuration.gateway.connected", connection: @connection)
+        Notifications.trigger('configuration.gateway.connected', connection: @connection)
 
         @options = options
 
@@ -152,15 +153,15 @@ module ROM
       # Create a table using the configured connection
       #
       # @api public
-      def create_table(*args, &block)
-        connection.create_table(*args, &block)
+      def create_table(...)
+        connection.create_table(...)
       end
 
       # Drops a table
       #
       # @api public
-      def drop_table(*args, &block)
-        connection.drop_table(*args, &block)
+      def drop_table(...)
+        connection.drop_table(...)
       end
 
       # Returns a list of datasets inferred from table names
@@ -249,5 +250,5 @@ module ROM
     end
   end
 
-  Configuration.register_event("configuration.gateway.connected")
+  Configuration.register_event('configuration.gateway.connected')
 end

data/lib/rom/sql/group_dsl.rb

@@ -9,11 +9,16 @@ module ROM
       private
 
       # @api private
-      def method_missing(meth, *args, &block)
+      def respond_to_missing?(_meth, _include_private = false)
+        true
+      end
+
+      # @api private
+      def method_missing(meth, ...)
         if schema.key?(meth)
           schema[meth].canonical
         else
-          ::Sequel::VIRTUAL_ROW.__send__(meth.to_s, *args, &block)
+          ::Sequel::VIRTUAL_ROW.__send__(meth.to_s, ...)
         end
       end
     end

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

@@ -13,8 +13,14 @@ module ROM
           yield(connection)
         end
 
-        def method_missing(m, *args, &block)
-          connection.public_send(m, *args, &block)
+        private
+
+        def method_missing(m, ...)
+          connection.public_send(m, ...)
+        end
+
+        def respond_to_missing?(meth, include_private = false)
+          connection.respond_to?(meth, include_private)
         end
       end
     end

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

@@ -16,8 +16,8 @@ module ROM
       class Migrator
         extend Initializer
 
-        DEFAULT_PATH = 'db/migrate'.freeze
-        VERSION_FORMAT = '%Y%m%d%H%M%S'.freeze
+        DEFAULT_PATH = 'db/migrate'
+        VERSION_FORMAT = '%Y%m%d%H%M%S'
         DEFAULT_INFERRER = Schema::Inferrer.new.suppress_errors.freeze
 
         param :connection
@@ -37,14 +37,14 @@ module ROM
         end
 
         # @api private
-        def migration(&block)
-          Sequel.migration(&block)
+        def migration(&)
+          Sequel.migration(&)
         end
 
         # @api private
         def create_file(name, version = generate_version, **options)
           sequence = options[:sequence] ? '%03d' % options[:sequence] : nil
-          filename = "#{ version }#{ sequence }_#{ name }.rb"
+          filename = "#{version}#{sequence}_#{name}.rb"
           content = options[:content] || migration_file_content
           path = options[:path] || self.path
           dirname = Pathname(path)

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

@@ -7,14 +7,20 @@ module ROM
       class Recorder
         attr_reader :operations
 
-        def initialize(&block)
+        def initialize(&)
           @operations = []
 
-          instance_exec(&block) if block
+          instance_exec(&) if block_given?
         end
 
-        def method_missing(m, *args, &block)
-          nested = block ? Recorder.new(&block).operations : EMPTY_ARRAY
+        private
+
+        def respond_to_missing?(_m, _include_private = false)
+          true
+        end
+
+        def method_missing(m, *args, &)
+          nested = block_given? ? Recorder.new(&).operations : EMPTY_ARRAY
           @operations << [m, args, nested]
         end
       end