rom-sql 3.6.2 → 4.0.0.alpha1

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rom/types/values'
+require "rom/types/values"
 
 module ROM
   module SQL
@@ -9,11 +9,9 @@ module ROM
       module Types
         # @see https://www.postgresql.org/docs/current/static/ltree.html
 
-        LTree = Type('ltree') do
+        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
@@ -122,8 +120,14 @@ 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
         #     #
@@ -224,17 +228,18 @@ module ROM
         #
         #   end
         module LTreeMethods
-          ASCENDANT = ['(', ' @> ', ')'].freeze
-          FIND_ASCENDANT = ['(', ' ?@> ', ')'].freeze
-          DESCENDANT = ['(', ' <@ ', ')'].freeze
-          FIND_DESCENDANT = ['(', ' ?<@ ', ')'].freeze
-          MATCH_ANY = ['(', ' ? ', ')'].freeze
-          MATCH_ANY_LQUERY = ['(', ' ?~ ', ')'].freeze
-          MATCH_LTEXTQUERY = ['(', ' @ ', ')'].freeze
-          MATCH_ANY_LTEXTQUERY = ['(', ' ?@ ', ')'].freeze
+          ASCENDANT = ["(", " @> ", ")"].freeze
+          FIND_ASCENDANT = ["(", " ?@> ", ")"].freeze
+          DESCENDANT = ["(", " <@ ", ")"].freeze
+          FIND_DESCENDANT = ["(", " ?<@ ", ")"].freeze
+          MATCH_ANY = ["(", " ? ", ")"].freeze
+          MATCH_ANY_LQUERY = ["(", " ?~ ", ")"].freeze
+          MATCH_LTEXTQUERY = ["(", " @ ", ")"].freeze
+          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)
@@ -248,45 +253,56 @@ module ROM
             Sequel::SQL::PlaceholderLiteralString.new(string, [expr, query])
           end
 
-          def build_array_query(query, array_type = 'lquery')
+          def build_array_query(query, array_type = "lquery")
             case query
             when ::Array
               ROM::SQL::Types::PG::Array(array_type)[query]
             when ::String
-              ROM::SQL::Types::PG::Array(array_type)[query.split(',')]
+              ROM::SQL::Types::PG::Array(array_type)[query.split(",")]
             end
           end
         end
 
-        TypeExtensions.register(ROM::SQL::Types::PG::Array('ltree', LTree)) do
+        TypeExtensions.register(ROM::SQL::Types::PG::Array("ltree", LTree)) do
           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,25 +310,35 @@ 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))
+            array = build_array_query(query, "ltree")
+            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))
+            array = build_array_query(query, "ltree")
+            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)
@@ -322,7 +348,8 @@ module ROM
                           else
                             ROM::Types::Values::TreePath.new(other)
                           end
-            Attribute[LTree].meta(sql_expr: Sequel::SQL::StringExpression.new(:'||', expr, other_value.to_s))
+            Attribute[LTree].meta(sql_expr: Sequel::SQL::StringExpression.new(:"||", expr,
+other_value.to_s))
           end
         end
       end

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

@@ -1,28 +1,15 @@
 # frozen_string_literal: true
 
-require 'ipaddr'
+require "ipaddr"
 
 module ROM
   module SQL
     module Postgres
       module Types
-        IPAddress = Type('inet') do
-          read = SQL::Types.Constructor(IPAddr) { |ip| ::IPAddr.new(ip.to_s) }
+        IPAddress = Type("inet") do
+          read = SQL::Types.Constructor(IPAddr) { |ip| IPAddr.new(ip.to_s) }
 
-          SQL::Types.Constructor(::IPAddr, &:to_s).meta(read: read)
-        end
-
-        IPNetwork = Type('cidr') do
-          read = SQL::Types.Constructor(IPAddr) do |ip|
-            case ip
-            when ::IPAddr
-              ip
-            when String
-              ::IPAddr.new(ip)
-            end
-          end
-
-          SQL::Types.Constructor(::IPAddr) { |ip| "#{ip}/#{ip.prefix}" }.meta(read: read)
+          SQL::Types.Constructor(IPAddr, &:to_s).meta(read: read)
         end
       end
     end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'sequel/core'
+require "sequel/core"
 
 Sequel.extension(:pg_range, :pg_range_ops)
 
@@ -9,10 +9,10 @@ module ROM
     module Postgres
       module Values
         Range = ::Struct.new(:lower, :upper, :bounds) do
-          PAREN_LEFT  = '('.freeze
-          PAREN_RIGHT = ')'.freeze
+          PAREN_LEFT  = "("
+          PAREN_RIGHT = ")"
 
-          def initialize(lower, upper, bounds = :'[)')
+          def initialize(lower, upper, bounds = :"[)")
             super
           end
 
@@ -33,22 +33,22 @@ module ROM
 
         @range_parsers = {
           int4range: Sequel::Postgres::PGRange::Parser.new(
-            'int4range', SQL::Types::Coercible::Integer
+            "int4range", SQL::Types::Coercible::Integer
           ),
           int8range: Sequel::Postgres::PGRange::Parser.new(
-            'int8range', SQL::Types::Coercible::Integer
+            "int8range", SQL::Types::Coercible::Integer
           ),
-          numrange:  Sequel::Postgres::PGRange::Parser.new(
-            'numrange', SQL::Types::Coercible::Integer
+          numrange: Sequel::Postgres::PGRange::Parser.new(
+            "numrange", SQL::Types::Coercible::Integer
           ),
-          tsrange:   Sequel::Postgres::PGRange::Parser.new(
-            'tsrange', ::Time.method(:parse)
+          tsrange: Sequel::Postgres::PGRange::Parser.new(
+            "tsrange", ::Time.method(:parse)
           ),
           tstzrange: Sequel::Postgres::PGRange::Parser.new(
-            'tstzrange', ::Time.method(:parse)
+            "tstzrange", ::Time.method(:parse)
           ),
           daterange: Sequel::Postgres::PGRange::Parser.new(
-            'daterange', ::Date.method(:parse)
+            "daterange", ::Date.method(:parse)
           )
         }.freeze
 
@@ -58,7 +58,7 @@ module ROM
             pg_range =
               if value.is_a?(Sequel::Postgres::PGRange)
                 value
-              elsif value && value.respond_to?(:to_s)
+              elsif value.respond_to?(:to_s)
                 @range_parsers[name].(value.to_s)
               else
                 value
@@ -67,9 +67,9 @@ module ROM
             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,23 +78,23 @@ 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? ? :'(' : :'[',
+              format("%s%s,%s%s",
+                     range.exclude_begin? ? :"(" : :"[",
                      range.lower,
                      range.upper,
-                     range.exclude_end? ? :')' : :']')
+                     range.exclude_end? ? :")" : :"]")
             end
 
             type.meta(read: read_type)
           end
         end
 
-        Int4Range = range('int4range', range_read_type(:int4range))
-        Int8Range = range('int8range', range_read_type(:int8range))
-        NumRange  = range('numrange',  range_read_type(:numrange))
-        TsRange   = range('tsrange',   range_read_type(:tsrange))
-        TsTzRange = range('tstzrange', range_read_type(:tstzrange))
-        DateRange = range('daterange', range_read_type(:daterange))
+        Int4Range = range("int4range", range_read_type(:int4range))
+        Int8Range = range("int8range", range_read_type(:int8range))
+        NumRange  = range("numrange",  range_read_type(:numrange))
+        TsRange   = range("tsrange",   range_read_type(:tsrange))
+        TsTzRange = range("tstzrange", range_read_type(:tstzrange))
+        DateRange = range("daterange", range_read_type(:daterange))
 
         module RangeOperators
           def contain(_type, expr, value)

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'sequel/core'
+require "sequel/core"
 
-require 'rom/sql/type_extensions'
+require "rom/sql/type_extensions"
 
 Sequel.extension(:pg_hstore)
 
@@ -11,25 +11,25 @@ module ROM
     module Postgres
       module Types
         def self.Type(name, type = yield)
-          type.meta(db_type: name, database: 'postgres')
+          type.meta(db_type: name, database: "postgres")
         end
 
-        UUID = Type('uuid', SQL::Types::String)
+        UUID = Type("uuid", SQL::Types::String)
 
-        HStore = Type('hstore') do
+        HStore = Type("hstore") do
           read = SQL::Types.Constructor(Hash, &:to_hash)
 
           SQL::Types.Constructor(Hash, &Sequel.method(:hstore))
             .meta(read: read)
         end
 
-        Bytea = Type('bytea') do
+        Bytea = Type("bytea") do
           SQL::Types.Constructor(Sequel::SQL::Blob, &Sequel::SQL::Blob.method(:new))
         end
 
-        Money = Type('money', SQL::Types::Decimal)
+        Money = Type("money", SQL::Types::Decimal)
 
-        XML = Type('xml', SQL::Types::String)
+        XML = Type("xml", SQL::Types::String)
       end
     end
 
@@ -39,9 +39,9 @@ module ROM
   end
 end
 
-require 'rom/sql/extensions/postgres/types/array'
-require 'rom/sql/extensions/postgres/types/json'
-require 'rom/sql/extensions/postgres/types/geometric'
-require 'rom/sql/extensions/postgres/types/network'
-require 'rom/sql/extensions/postgres/types/range'
-require 'rom/sql/extensions/postgres/types/ltree'
+require "rom/sql/extensions/postgres/types/array"
+require "rom/sql/extensions/postgres/types/json"
+require "rom/sql/extensions/postgres/types/geometric"
+require "rom/sql/extensions/postgres/types/network"
+require "rom/sql/extensions/postgres/types/range"
+require "rom/sql/extensions/postgres/types/ltree"

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'rom/sql/extensions/postgres/commands'
-require 'rom/sql/extensions/postgres/types'
-require 'rom/sql/extensions/postgres/type_builder'
-require 'rom/sql/extensions/postgres/type_serializer'
-require 'rom/plugins/relation/sql/postgres/explain'
-require 'rom/plugins/relation/sql/postgres/full_text_search'
+require "rom/sql/extensions/postgres/commands"
+require "rom/sql/extensions/postgres/types"
+require "rom/sql/extensions/postgres/type_builder"
+require "rom/sql/extensions/postgres/type_serializer"
+require "rom/plugins/relation/sql/postgres/explain"
+require "rom/plugins/relation/sql/postgres/full_text_search"

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/log_subscriber'
+require "active_support/log_subscriber"
 
 module ROM
   module SQL
@@ -10,8 +10,8 @@ module ROM
 
         payload = event.payload
 
-        name = format('%s (%.1fms)', payload[:name], event.duration)
-        sql  = payload[:sql].squeeze(' ')
+        name = format("%s (%.1fms)", payload[:name], event.duration)
+        sql  = payload[:sql].squeeze(" ")
         binds = payload[:binds].to_a.inspect if payload[:binds]
 
         if odd?

data/lib/rom/sql/extensions/sqlite/types.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry-types'
+require "dry-types"
 
 module ROM
   module SQL

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

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
-require 'rom/sql/extensions/sqlite/types'
-require 'rom/sql/extensions/sqlite/type_builder'
+require "rom/sql/extensions/sqlite/types"
+require "rom/sql/extensions/sqlite/type_builder"

data/lib/rom/sql/extensions.rb

@@ -1,29 +1,29 @@
 # frozen_string_literal: true
 
-require 'dry/core/extensions'
+require "dry/core/extensions"
 
 module ROM
   module SQL
     extend Dry::Core::Extensions
 
     register_extension(:postgres) do
-      require 'rom/sql/extensions/postgres'
+      require "rom/sql/extensions/postgres"
     end
 
     register_extension(:mysql) do
-      require 'rom/sql/extensions/mysql'
+      require "rom/sql/extensions/mysql"
     end
 
     register_extension(:sqlite) do
-      require 'rom/sql/extensions/sqlite'
+      require "rom/sql/extensions/sqlite"
     end
 
     register_extension(:active_support_notifications) do
-      require 'rom/sql/extensions/active_support_notifications'
+      require "rom/sql/extensions/active_support_notifications"
     end
 
     register_extension(:rails_log_subscriber) do
-      require 'rom/sql/extensions/rails_log_subscriber'
+      require "rom/sql/extensions/rails_log_subscriber"
     end
   end
 end

data/lib/rom/sql/foreign_key.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "dry/core/equalizer"
+
 module ROM
   module SQL
     # @api private
@@ -11,7 +13,7 @@ module ROM
 
       param :attributes
 
-      param :parent_table, type: Dry::Types['strict.symbol']
+      param :parent_table, type: Dry::Types["strict.symbol"]
 
       option :parent_keys, default: -> { DEFAULT_PARENT_KEYS }
     end

data/lib/rom/sql/function.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'rom/attribute'
-require 'rom/sql/attribute_wrapping'
+require "rom/attribute"
+require "rom/sql/attribute_wrapping"
 
 module ROM
   module SQL
@@ -15,14 +15,14 @@ module ROM
         # @api private
         def frame_limit(value)
           case value
-          when :current then 'CURRENT ROW'
-          when :start then 'UNBOUNDED PRECEDING'
-          when :end then 'UNBOUNDED FOLLOWING'
+          when :current then "CURRENT ROW"
+          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
@@ -32,15 +32,16 @@ module ROM
 
       # @api private
       WINDOW_FRAMES = Hash.new do |cache, frame|
-        type = frame.key?(:rows) ? 'ROWS' : 'RANGE'
+        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
       #
@@ -89,12 +90,7 @@ module ROM
 
       # @api private
       def new(&block)
-        case func
-        when ::Sequel::SQL::Function
-          meta(func: ::Sequel::SQL::Function.new!(func.name, func.args.map(&block), func.opts))
-        else
-          meta(func: func)
-        end
+        meta(func: ::Sequel::SQL::Function.new!(func.name, func.args.map(&block), func.opts))
       end
 
       # @see Attribute#qualified?
@@ -109,7 +105,7 @@ module ROM
       # @api public
       def is(other)
         ::ROM::SQL::Attribute[::ROM::SQL::Types::Bool].meta(
-          sql_expr: ::Sequel::SQL::BooleanExpression.new(:'=', func, other)
+          sql_expr: ::Sequel::SQL::BooleanExpression.new(:"=", func, other)
         )
       end
 
@@ -190,7 +186,7 @@ module ROM
       def case(mapping)
         mapping = mapping.dup
         otherwise = mapping.delete(:else) do
-          raise ArgumentError, 'provide the default case using the :else keyword'
+          raise ArgumentError, "provide the default case using the :else keyword"
         end
 
         Attribute[type].meta(sql_expr: ::Sequel.case(mapping, otherwise))
@@ -214,7 +210,7 @@ module ROM
       def filter(condition = Undefined, &block)
         if block
           conditions = schema.restriction(&block)
-          conditions = conditions & condition unless condition.equal?(Undefined)
+          conditions &= condition unless condition.equal?(Undefined)
         else
           conditions = condition
         end