rubocop 0.29.1 → 0.30.0

data/lib/rubocop/cop/performance/size.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of `count` on an
+      # `Array` and `Hash` and change them to `size`.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].count
+      #
+      #   # bad
+      #   {a: 1, b: 2, c: 3}.count
+      #
+      #   # good
+      #   [1, 2, 3].size
+      #
+      #   # good
+      #   {a: 1, b: 2, c: 3}.size
+      #
+      #   # good
+      #   [1, 2, 3].count { |e| e > 2 }
+      # TODO: Add advanced detection of variables that could
+      # have been assigned to an array or a hash.
+      class Size < Cop
+        MSG = 'Use `size` instead of `count`.'
+
+        def on_send(node)
+          receiver, method = *node
+
+          return if receiver.nil?
+          return unless method == :count
+          return unless array?(receiver) || hash?(receiver)
+          return if node.parent && node.parent.block_type?
+
+          add_offense(node, node.loc.selector)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.selector, 'size')
+          end
+        end
+
+        private
+
+        def array?(node)
+          receiver, method = *node
+          _, constant = *receiver
+
+          node.array_type? || constant == :Array || method == :to_a
+        end
+
+        def hash?(node)
+          receiver, method = *node
+          _, constant = *receiver
+
+          node.hash_type? || constant == :Hash || method == :to_h
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the correct use of Date methods,
+      # such as Date.today, Date.current etc.
+      #
+      # Using Date.today is dangerous, because it doesn't know anything about
+      # Rails time zone. You must use Time.zone.today instead.
+      #
+      # The cop also reports warnings when you are using 'to_time' method,
+      # because it doesn't know about Rails time zone too.
+      #
+      # Two styles are supported for this cop. When EnforcedStyle is 'always'
+      # then the Date methods (today, current, yesterday, tomorrow)
+      # are prohibited and the usage of both 'to_time'
+      # and 'to_time_in_current_zone' is reported as warning.
+      #
+      # When EnforcedStyle is 'acceptable' then only 'Date.today' is prohibited
+      # and only 'to_time' is reported as warning.
+      #
+      # @example
+      #   # no offense
+      #   Time.zone.today
+      #   Time.zone.today - 1.day
+      #
+      #   # acceptable
+      #   Date.current
+      #   Date.yesterday
+      #
+      #   # always reports offense
+      #   Date.today
+      #   date.to_time
+      #
+      #   # reports offense only when style is 'always'
+      #   date.to_time_in_current_zone
+      class Date < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Do not use `%s` without zone. Use `%s` instead.'
+
+        MSG_SEND =  'Do not use `%s` on Date objects,' \
+                    'because it knows nothing about time zone in use.'
+
+        BAD_DAYS = [:today, :current, :yesterday, :tomorrow]
+
+        def on_const(node)
+          _, klass = *node.children
+
+          return unless method_send?(node)
+
+          check_date_node(node.parent) if klass == :Date
+        end
+
+        def on_send(node)
+          method_name = extract_method(node)
+          return unless bad_methods.include?(method_name)
+
+          add_offense(node, :selector,
+                      format(MSG_SEND,
+                             method_name
+                            )
+                     )
+        end
+
+        private
+
+        def check_date_node(node)
+          chain = extract_method_chain(node)
+          return if (chain & bad_days).empty?
+
+          method_name = *(chain & bad_days)
+
+          add_offense(node, :selector,
+                      format(MSG,
+                             "Date.#{method_name}",
+                             'Time.zone.today')
+                     )
+        end
+
+        def extract_method_chain(node)
+          chain = []
+          p = node
+          while !p.nil? && p.send_type?
+            chain << extract_method(p)
+            p = p.parent
+          end
+          chain
+        end
+
+        def extract_method(node)
+          _receiver, method_name, *_args = *node
+          method_name
+        end
+
+        # checks that parent node of send_type
+        # and receiver is the given node
+        def method_send?(node)
+          return false unless node.parent.send_type?
+
+          receiver, _method_name, *_args = *node.parent
+
+          receiver == node
+        end
+
+        def good_days
+          style == :always ? [] : [:current, :yesterday, :tomorrow]
+        end
+
+        def bad_days
+          BAD_DAYS - good_days
+        end
+
+        def bad_methods
+          style == :always ? [:to_time, :to_time_in_current_zone] : [:to_time]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop is used to identify usages of `where.first` and
+      # change them to use `find_by` instead.
+      #
+      # @example
+      #   # bad
+      #   User.where(name: 'Bruce').first
+      #   User.where(name: 'Bruce').take
+      #
+      #   # good
+      #   User.find_by(name: 'Bruce')
+      class FindBy < Cop
+        MSG = 'Use `find_by` instead of `where.%s`.'
+        TARGET_SELECTORS = [:first, :take]
+
+        def on_send(node)
+          receiver, second_method, _selector = *node
+          return unless TARGET_SELECTORS.include?(second_method)
+          return if receiver.nil?
+          _scope, first_method = *receiver
+          return unless first_method == :where
+          begin_of_offense = receiver.loc.selector.begin_pos
+          end_of_offense = node.loc.selector.end_pos
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                            begin_of_offense,
+                                            end_of_offense)
+
+          add_offense(node, range, format(MSG, second_method))
+        end
+
+        def autocorrect(node)
+          receiver, = *node
+          where_loc = receiver.loc.selector
+          first_loc = Parser::Source::Range.new(
+            node.loc.expression.source_buffer,
+            node.loc.dot.begin_pos,
+            node.loc.selector.end_pos
+          )
+
+          @corrections << lambda do |corrector|
+            corrector.replace(where_loc, 'find_by')
+            corrector.replace(first_loc, '')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop is used to identify usages of `all.each` and
+      # change them to use `all.find_each` instead.
+      #
+      # @example
+      #   # bad
+      #   User.all.each
+      #
+      #   # good
+      #   User.all.find_each
+      class FindEach < Cop
+        MSG = 'Use `find_each` instead of `each`.'
+
+        SCOPE_METHODS = [:all, :where]
+
+        def on_send(node)
+          receiver, second_method, _selector = *node
+          return unless second_method == :each
+          return if receiver.nil?
+
+          _model, first_method = *receiver
+          return unless SCOPE_METHODS.include?(first_method)
+
+          add_offense(node, node.loc.selector, MSG)
+        end
+
+        def autocorrect(node)
+          each_loc = node.loc.selector
+
+          @corrections << lambda do |corrector|
+            corrector.replace(each_loc, 'find_each')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the use of Time methods without zone.
+      #
+      # Built on top of Ruby on Rails style guide (https://github.com/bbatsov/rails-style-guide#time)
+      # and the article http://danilenko.org/2012/7/6/rails_timezones/ .
+      #
+      # Two styles are supported for this cop. When EnforcedStyle is 'always'
+      # then only use of Time.zone is allowed.
+      #
+      # When EnforcedStyle is 'acceptable' then it's also allowed
+      # to use Time.in_time_zone.
+      #
+      # @example
+      #   # always offense
+      #   Time.now
+      #   Time.parse('2015-03-02 19:05:37')
+      #
+      #   # no offense
+      #   Time.zone.now
+      #   Time.zone.parse('2015-03-02 19:05:37')
+      #
+      #   # no offense only if style is 'acceptable'
+      #   DateTime.strptime(str, "%Y-%m-%d %H:%M %Z").in_time_zone
+      #   Time.at(timestamp).in_time_zone
+      class TimeZone < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Do not use `%s` without zone. Use `%s` instead.'
+
+        TIMECLASS = [:Time, :DateTime]
+
+        DANGER_METHODS = [:now, :local, :new, :strptime, :parse, :at]
+
+        def on_const(node)
+          _module, klass = *node
+
+          return unless method_send?(node)
+
+          check_time_node(klass, node.parent) if TIMECLASS.include?(klass)
+        end
+
+        private
+
+        def check_time_node(klass, node)
+          chain = extract_method_chain(node)
+          return if (chain & DANGER_METHODS).empty? ||
+                    !(chain & good_methods).empty?
+
+          method_name = *(chain & DANGER_METHODS)
+
+          add_offense(node, :selector,
+                      format(MSG,
+                             "#{klass}.#{method_name}",
+                             "#Time.zone.#{method_name}")
+                     )
+        end
+
+        def extract_method_chain(node)
+          chain = []
+          p = node
+          while !p.nil? && p.send_type?
+            chain << extract_method(p)
+            p = p.parent
+          end
+          chain
+        end
+
+        def extract_method(node)
+          _receiver, method_name, *_args = *node
+          method_name
+        end
+
+        # checks that parent node of send_type
+        # and receiver is the given node
+        def method_send?(node)
+          return false unless node.parent.send_type?
+
+          receiver, _method_name, *_args = *node.parent
+
+          receiver == node
+        end
+
+        def good_methods
+          style == :always ? [:zone] : [:zone, :in_time_zone]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for cases when you could use a block
+      # accepting version of a method that does automatic
+      # resource cleanup.
+      #
+      # @example
+      #
+      #   # bad
+      #   f = File.open('file')
+      #
+      #   # good
+      #   f = File.open('file') do
+      #     ...
+      #   end
+      class AutoResourceCleanup < Cop
+        include AST::Sexp
+        MSG = 'Use the block version of `%s.%s`.'
+
+        TARGET_METHODS = [
+          [:File, :open]
+        ]
+
+        def on_send(node)
+          receiver_node, method_name, *_arg_nodes = *node
+
+          TARGET_METHODS.each do |(target_class, target_method)|
+            target_receiver = s(:const, nil, target_class)
+
+            next if receiver_node != target_receiver
+            next if method_name != target_method
+            next if node.parent && node.parent.block_type?
+
+            add_offense(node,
+                        :expression,
+                        format(MSG, target_class, target_method))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,186 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Check for uses of braces or do/end around single line or
+      # multi-line blocks.
+      class BlockDelimiters < Cop
+        include ConfigurableEnforcedStyle
+        include AutocorrectUnlessChangingAST
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+          return unless args.any?
+
+          block = get_block(args.last)
+          return unless block && !parentheses?(node) && !operator?(method_name)
+
+          # If there are no parentheses around the arguments, then braces and
+          # do-end have different meaning due to how they bind, so we allow
+          # either.
+          ignore_node(block)
+        end
+
+        def on_block(node)
+          return if ignored_node?(node)
+
+          if proper_block_style?(node)
+            correct_style_detected
+          else
+            add_offense(node, :begin) { opposite_style_detected }
+          end
+        end
+
+        private
+
+        def message(node)
+          block_begin = node.loc.begin.source
+          block_length = Util.block_length(node)
+
+          case style
+          when :line_count_based
+            if block_length > 0
+              'Avoid using `{...}` for multi-line blocks.'
+            else
+              'Prefer `{...}` over `do...end` for single-line blocks.'
+            end
+          when :semantic
+            if block_begin == '{'
+              'Prefer `do...end` over `{...}` for procedural blocks.'
+            else
+              'Prefer `{...}` over `do...end` for functional blocks.'
+            end
+          end
+        end
+
+        def correction(node)
+          lambda do |corrector|
+            b, e = node.loc.begin, node.loc.end
+            if b.is?('{')
+              # If the left brace is not preceded by a whitespace character,
+              # then we need a space before `do` to get valid Ruby code.
+              if b.source_buffer.source[b.begin_pos - 1, 1] =~ /\S/
+                corrector.insert_before(b, ' ')
+              end
+              corrector.replace(b, 'do')
+              corrector.replace(e, 'end')
+            else
+              corrector.replace(b, '{')
+              corrector.replace(e, '}')
+            end
+          end
+        end
+
+        def get_block(node)
+          case node.type
+          when :block
+            node
+          when :send
+            receiver, _method_name, *_args = *node
+            get_block(receiver) if receiver
+          end
+        end
+
+        def parentheses?(send_node)
+          send_node.loc.begin
+        end
+
+        def operator?(method_name)
+          method_name =~ /^\W/
+        end
+
+        def proper_block_style?(node)
+          case style
+          when :line_count_based
+            line_count_based_block_style?(node)
+          when :semantic
+            semantic_block_style?(node)
+          end
+        end
+
+        def line_count_based_block_style?(node)
+          block_length = Util.block_length(node)
+          block_begin = node.loc.begin.source
+
+          if block_length > 0
+            block_begin != '{'
+          else
+            block_begin == '{'
+          end
+        end
+
+        def semantic_block_style?(node)
+          method_name = extract_method_name_from_block(node)
+          return true if ignored_method?(method_name)
+
+          block_begin = node.loc.begin.source
+
+          if block_begin == '{'
+            functional_method?(method_name) || functional_block?(node)
+          else
+            procedural_method?(method_name) || !return_value_used?(node)
+          end
+        end
+
+        def extract_method_name_from_block(block)
+          node, _args, _body = *block
+          _receiver, method_name, *_args = *node
+
+          method_name
+        end
+
+        def ignored_method?(method_name)
+          ignored_methods.include?(method_name)
+        end
+
+        def functional_method?(method_name)
+          functional_methods.include?(method_name)
+        end
+
+        def functional_block?(node)
+          return_value_used?(node) || return_value_of_scope?(node)
+        end
+
+        def procedural_method?(method_name)
+          procedural_methods.include?(method_name)
+        end
+
+        def return_value_used?(node)
+          return unless node.parent
+
+          # If there are parentheses around the block, check if that
+          # is being used.
+          if node.parent.begin_type?
+            return_value_used?(node.parent)
+          else
+            Util::ASGN_NODES.include?(node.parent.type) ||
+              node.parent.send_type?
+          end
+        end
+
+        def return_value_of_scope?(node)
+          return unless node.parent
+
+          conditional?(node.parent) || node.parent.children.last == node
+        end
+
+        def procedural_methods
+          cop_config['ProceduralMethods'].map(&:to_sym)
+        end
+
+        def functional_methods
+          cop_config['FunctionalMethods'].map(&:to_sym)
+        end
+
+        def ignored_methods
+          cop_config['IgnoredMethods'].map(&:to_sym)
+        end
+
+        def conditional?(node)
+          node.if_type? || node.or_type? || node.and_type?
+        end
+      end
+    end
+  end
+end