rubocop 0.63.0 → 0.63.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7aaecd68a4876e64c43f009e849b228a26805bfe
-  data.tar.gz: 68a8b80a3f44980737704d596a595548bc6cb086
+SHA256:
+  metadata.gz: 403ba108281ac77da6c733ad24b88350e4b4a3055ad36b6059d7784cbf4df56e
+  data.tar.gz: 86ebf007930c2de6e2f5eddbd0a6fba6e99ce9a7645f6407fdd4554a4e3c632c
 SHA512:
-  metadata.gz: e2f5aacc075c83cc70ff025a59f4ed5201de381be89da00c93ed23fceb2a43d09960a653407ee6a040a68e9f6f199bed50342fdb413c84d3b22ee8ff0f840f08
-  data.tar.gz: c9883abe7b2d4221e7af6a36f3d9aeeeca51de1a36d558c2a55a6a5b33cad9948a53bd9eeda38e4565f56b1aed85b7e98c4d2a8e2d939cb53984ad9eaec63088
+  metadata.gz: 65c260a9df4e731b52ed42e5412d100e71199d5b75e6dac98adaf097020b351019c3fabedd99f2c34465d414eba0439680aeb7799ece4321c63918b4ac2e46e9
+  data.tar.gz: 5bfe411917f9d371b3ce33464297b5aa7840959dccf1275553545601af6b5228a7e770e3993663b98d5880f91f18dfdb94cf55cfa697af923e63c3b9fb3bcd8f

data/README.md

@@ -53,7 +53,7 @@ haven't reached version 1.0 yet). To prevent an unwanted RuboCop update you
 might want to use a conservative version locking in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 0.63.0', require: false
+gem 'rubocop', '~> 0.63.1', require: false
 ```
 
 ## Quickstart

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -94,7 +94,7 @@ module RuboCop
         begin_line_num = previous_line_num - base_line_num + 1
         end_line_num = node.first_line - base_line_num + 1
         lines = source_in_lines[begin_line_num...end_line_num]
-        "\n" + lines.join("\n").split(node.source).first
+        "\n#{(lines.join("\n").split(node.source).first || '')}"
       end
 
       def fix_escaped_content(word_node, escape, delimiters)

data/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb

@@ -133,6 +133,7 @@ module RuboCop
           # Although there are multiple choices for a correct column,
           # select the first one of candidates to determine a specification.
           correct_column = candidates.first
+          @column_delta = correct_column - right_paren.column
           add_offense(right_paren,
                       location: right_paren,
                       message: message(correct_column,

data/lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb

@@ -34,12 +34,13 @@ module RuboCop
         def check(node)
           return unless node.method_name == :initialize
 
-          check_body(node)
+          check_body(node.body)
         end
 
         # @param [DefNode] node a constructor definition
-        def check_body(node)
-          body = node.body
+        def check_body(body)
+          return if body.nil?
+
           case body.type
           when :begin
             check_body_lines(body.child_nodes)

data/lib/rubocop/cop/rails/relative_date_constant.rb

@@ -19,18 +19,15 @@ module RuboCop
       #     end
       #   end
       class RelativeDateConstant < Cop
+        include RangeHelp
+
         MSG = 'Do not assign %<method_name>s to constants as it ' \
               'will be evaluated only once.'.freeze
 
-        RELATIVE_DATE_METHODS = %i[ago from_now since until].freeze
-
         def on_casgn(node)
-          _scope, _constant, rhs = *node
-
-          # rhs would be nil in a or_asgn node
-          return unless rhs
-
-          check_node(rhs)
+          relative_date_assignment?(node) do |method_name|
+            add_offense(node, message: format(MSG, method_name: method_name))
+          end
         end
 
         def on_masgn(node)
@@ -39,20 +36,29 @@ module RuboCop
           return unless rhs && rhs.array_type?
 
           lhs.children.zip(rhs.children).each do |(name, value)|
-            check_node(value) if name.casgn_type?
+            next unless name.casgn_type?
+
+            relative_date?(value) do |method_name|
+              add_offense(node,
+                          location: range_between(name.loc.expression.begin_pos,
+                                                  value.loc.expression.end_pos),
+                          message: format(MSG, method_name: method_name))
+            end
           end
         end
 
         def on_or_asgn(node)
-          lhs, rhs = *node
-
-          return unless lhs.casgn_type?
-
-          check_node(rhs)
+          relative_date_or_assignment?(node) do |method_name|
+            add_offense(node, message: format(MSG, method_name: method_name))
+          end
         end
 
         def autocorrect(node)
-          _scope, const_name, value = *node
+          return unless node.casgn_type?
+
+          scope, const_name, value = *node
+          return unless scope.nil?
+
           indent = ' ' * node.loc.column
           new_code = ["def self.#{const_name.downcase}",
                       "#{indent}#{value.source}",
@@ -62,27 +68,25 @@ module RuboCop
 
         private
 
-        def check_node(node)
-          return unless node.irange_type? ||
-                        node.erange_type? ||
-                        node.send_type?
-
-          # for range nodes we need to check both their boundaries
-          nodes = node.send_type? ? [node] : node.children
-
-          nodes.each do |n|
-            if relative_date_method?(n)
-              add_offense(node.parent,
-                          message: format(MSG, method_name: n.method_name))
-            end
-          end
-        end
-
-        def relative_date_method?(node)
-          node.send_type? &&
-            RELATIVE_DATE_METHODS.include?(node.method_name) &&
-            !node.arguments?
-        end
+        def_node_matcher :relative_date_assignment?, <<-PATTERN
+          {
+            (casgn _ _ (send _ ${:since :from_now :after :ago :until :before}))
+            (casgn _ _ ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before})))
+            (casgn _ _ ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _))
+          }
+        PATTERN
+
+        def_node_matcher :relative_date_or_assignment?, <<-PATTERN
+          (:or_asgn (casgn _ _) (send _ ${:since :from_now :after :ago :until :before}))
+        PATTERN
+
+        def_node_matcher :relative_date?, <<-PATTERN
+          {
+            ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before}))
+            ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _)
+            (send _ ${:since :from_now :after :ago :until :before})
+          }
+        PATTERN
       end
     end
   end

data/lib/rubocop/cop/style/copyright.rb

@@ -20,7 +20,7 @@ module RuboCop
 
         MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
               'any code.'.freeze
-        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in' \
+        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in ' \
                                     'your RuboCop config'.freeze
 
         def investigate(processed_source)

data/lib/rubocop/rspec/cop_helper.rb

@@ -38,6 +38,8 @@ module CopHelper
   end
 
   def autocorrect_source(source, file = nil)
+    RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+    RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
     cop.instance_variable_get(:@options)[:auto_correct] = true
     processed_source = parse_source(source, file)
     _investigate(cop, processed_source)

data/lib/rubocop/rspec/expect_offense.rb

@@ -38,24 +38,65 @@ module RuboCop
     #       'Avoid chaining a method call on a do...end block.'
     #     )
     #
+    # Auto-correction can be tested using `expect_correction` after
+    # `expect_offense`.
+    #
+    # @example `expect_offense` and `expect_correction`
+    #
+    #   expect_offense(<<-RUBY.strip_indent)
+    #     x % 2 == 0
+    #     ^^^^^^^^^^ Replace with `Integer#even?`.
+    #   RUBY
+    #
+    #   expect_correction(<<-RUBY.strip_indent)
+    #     x.even?
+    #   RUBY
+    #
     # If you do not want to specify an offense then use the
     # companion method `expect_no_offenses`. This method is a much
     # simpler assertion since it just inspects the source and checks
     # that there were no offenses. The `expect_offense` method has
     # to do more work by parsing out lines that contain carets.
     module ExpectOffense
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       def expect_offense(source, file = nil)
+        RuboCop::Formatter::DisabledConfigFormatter
+          .config_to_allow_offenses = {}
+        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+        cop.instance_variable_get(:@options)[:auto_correct] = true
+
         expected_annotations = AnnotatedSource.parse(source)
 
         if expected_annotations.plain_source == source
-          raise 'Use expect_no_offenses to assert that no offenses are found'
+          raise 'Use `expect_no_offenses` to assert that no offenses are found'
+        end
+
+        @processed_source = parse_source(expected_annotations.plain_source,
+                                         file)
+
+        unless @processed_source.valid_syntax?
+          raise 'Error parsing example code'
         end
 
-        inspect_source(expected_annotations.plain_source, file)
+        _investigate(cop, @processed_source)
         actual_annotations =
           expected_annotations.with_offense_annotations(cop.offenses)
+
         expect(actual_annotations.to_s).to eq(expected_annotations.to_s)
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def expect_correction(correction)
+        unless @processed_source
+          raise '`expect_correction` must follow `expect_offense`'
+        end
+
+        corrector =
+          RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
+        new_source = corrector.rewrite
+
+        expect(new_source).to eq(correction)
+      end
 
       def expect_no_offenses(source, file = nil)
         inspect_source(source, file)

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.63.0'.freeze
+    STRING = '0.63.1'.freeze
 
     MSG = '%<version>s (using Parser %<parser_version>s, running on ' \
           '%<ruby_engine>s %<ruby_version>s %<ruby_platform>s)'.freeze

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 0.63.0
+  version: 0.63.1
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-16 00:00:00.000000000 Z
+date: 2019-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jaro_winkler
@@ -830,8 +830,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Automatic Ruby code style checking tool.