rubocop -a

Author: flash-gordon

.rubocop.yml

@@ -89,6 +89,10 @@ Naming/MethodName:
 Naming/MethodParameterName:
   Enabled: false
 
+Style/MultilineBlockChain:
+  Exclude:
+    - "spec/**/*.rb"
+
 Style/MutableConstant:
   Exclude:
     - "spec/**/*.rb"

Rakefile

@@ -1,4 +1,4 @@
-require "rspec/core/rake_task"
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 

lib/rom/plugins/relation/sql/auto_restrictions.rb

@@ -46,7 +46,7 @@ def self.restriction_methods(schema)
               next if index.partial?
 
               attributes = index.to_a
-              meth_name = :"by_#{ attributes.map(&:name).join('_and_') }"
+              meth_name = :"by_#{attributes.map(&:name).join("_and_")}"
 
               next if generated.include?(meth_name)
 

lib/rom/plugins/relation/sql/instrumentation.rb

@@ -31,8 +31,12 @@ module Instrumentation
           subscribe('configuration.relations.registry.created') do |event|
             registry = event[:registry]
 
-            relations = registry.select { |_, r| r.adapter == :sql && r.respond_to?(:notifications) }.to_h
-            db_notifications = relations.values.map { |r| [r.dataset.db, r.notifications] }.uniq.to_h
+            relations = registry.select { |_, r|
+              r.adapter == :sql && r.respond_to?(:notifications)
+            }.to_h
+            db_notifications = relations.values.map { |r|
+              [r.dataset.db, r.notifications]
+            }.uniq.to_h
 
             db_notifications.each do |db, notifications|
               next if db.respond_to?(:rom_instrumentation?)

lib/rom/plugins/relation/sql/postgres/full_text_search.rb

@@ -36,8 +36,8 @@ module FullTextSearch
             # @see https://www.postgresql.org/docs/current/textsearch.html PostgreSQL docs
             #
             # @api public
-            def full_text_search(*args, &block)
-              new dataset.__send__(__method__, *args, &block)
+            def full_text_search(...)
+              new dataset.__send__(__method__, ...)
             end
           end
         end
@@ -48,6 +48,8 @@ def full_text_search(*args, &block)
 
 ROM.plugins do
   adapter :sql do
-    register :pg_full_text_search, ROM::Plugins::Relation::SQL::Postgres::FullTextSearch, type: :relation
+    register :pg_full_text_search,
+             ROM::Plugins::Relation::SQL::Postgres::FullTextSearch,
+             type: :relation
   end
 end

lib/rom/plugins/relation/sql/postgres/streaming.rb

@@ -13,21 +13,21 @@ module Streaming
 
             class StreamingNotSupportedError < StandardError; end
 
-            subscribe("configuration.gateway.connected") do |opts|
+            subscribe('configuration.gateway.connected') do |opts|
               conn = opts[:connection]
 
               next unless conn.database_type.to_sym == :postgres
 
               next if defined?(JRUBY_VERSION)
 
               begin
-                require "sequel_pg"
+                require 'sequel_pg'
               rescue LoadError
-                raise StreamingNotSupportedError, "add sequel_pg to Gemfile to use pg_streaming"
+                raise StreamingNotSupportedError, 'add sequel_pg to Gemfile to use pg_streaming'
               end
 
               unless Sequel::Postgres.supports_streaming?
-                raise StreamingNotSupportedError, "postgres version does not support streaming"
+                raise StreamingNotSupportedError, 'postgres version does not support streaming'
               end
 
               conn.extension(:pg_streaming)
@@ -52,7 +52,7 @@ def self.included(klass)
               #
               # @api publicY_VERSION
               def stream_each
-                raise StreamingNotSupportedError, "not supported on jruby"
+                raise StreamingNotSupportedError, 'not supported on jruby'
               end
             else
               # Allows you to stream returned rows one at a time, instead of
@@ -80,7 +80,7 @@ def stream_each
 
               module Combined
                 def stream_each
-                  raise StreamingNotSupportedError, "not supported on combined relations"
+                  raise StreamingNotSupportedError, 'not supported on combined relations'
                 end
               end
 

lib/rom/sql/associations/many_to_many.rb

@@ -17,10 +17,10 @@ def call(target: self.target)
 
           schema =
             if left.schema.key?(foreign_key)
-              if target != self.target
-                target.schema.merge(join_schema)
-              else
+              if target == self.target
                 left.schema.uniq.project(*columns)
+              else
+                target.schema.merge(join_schema)
               end
             else
               target_schema

lib/rom/sql/attribute.rb

@@ -263,8 +263,8 @@ def in(*args)
       # @return [SQL::Function]
       #
       # @api public
-      def func(&block)
-        ProjectionDSL.new(name => self).call(&block).first
+      def func(&)
+        ProjectionDSL.new(name => self).call(&).first
       end
 
       # Create a CONCAT function from the attribute
@@ -380,19 +380,19 @@ def case(mapping)
       #
       # @api private
       def sql_expr
-        @sql_expr ||= (meta[:sql_expr] || to_sql_name)
+        @sql_expr ||= meta[:sql_expr] || to_sql_name
       end
 
       # Delegate to sql expression if it responds to a given method
       #
       # @api private
-      def method_missing(meth, *args, &block)
+      def method_missing(meth, *args, &)
         if OPERATORS.include?(meth)
           __cmp__(meth, args[0])
         elsif extensions.key?(meth)
-          extensions[meth].(type, sql_expr, *args, &block)
+          extensions[meth].(type, sql_expr, *args, &)
         elsif sql_expr.respond_to?(meth)
-          meta(sql_expr: sql_expr.__send__(meth, *args, &block))
+          meta(sql_expr: sql_expr.__send__(meth, *args, &))
         else
           super
         end

lib/rom/sql/attribute_aliasing.rb

@@ -19,8 +19,7 @@ def aliased(alias_name)
           sql_expr: alias_sql_expr(sql_expr, new_alias_name)
         )
       end
-      alias as aliased
-
+      alias_method :as, :aliased
 
       # Return true if this attribute is an aliased projection
       #
@@ -46,16 +45,18 @@ def aliased(alias_name)
       #
       # @api private
       def aliased_projection?
-        self.meta[:sql_expr].is_a?(Sequel::SQL::AliasedExpression)
+        meta[:sql_expr].is_a?(::Sequel::SQL::AliasedExpression)
       end
 
       private
 
       # @api private
       def alias_sql_expr(sql_expr, new_alias)
         case sql_expr
-        when Sequel::SQL::AliasedExpression
-          Sequel::SQL::AliasedExpression.new(sql_expr.expression, new_alias, sql_expr.columns)
+        when ::Sequel::SQL::AliasedExpression
+          ::Sequel::SQL::AliasedExpression.new(
+            sql_expr.expression, new_alias, sql_expr.columns
+          )
         else
           sql_expr.as(new_alias)
         end
@@ -70,7 +71,7 @@ def extract_alias_names(alias_name)
           # attribute in a way that will map the the requested alias name.
           # Without this, the attribute will silently ignore the requested alias
           # name and default to the pre-existing name.
-          new_name = "#{meta[:wrapped]}_#{options[:alias]}".to_sym
+          new_name = :"#{meta[:wrapped]}_#{options[:alias]}"
 
           # Essentially, this makes it so "wrapped" attributes aren't true
           # aliases, in that we actually alias the wrapped attribute, we use

lib/rom/sql/commands/create.rb

@@ -60,10 +60,11 @@ def multi_insert(tuples)
         # Yields tuples for insertion or return an enumerator
         #
         # @api private
-        def with_input_tuples(tuples)
-          input_tuples = Array([tuples]).flatten(1).map
+        def with_input_tuples(tuples, &)
+          input_tuples = [tuples].flatten(1).map
           return input_tuples unless block_given?
-          input_tuples.each { |tuple| yield(tuple) }
+
+          input_tuples.each(&)
         end
       end
     end