sabat-rubocop 0.9.0

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether comments have a leading space
+      # after the # denoting the start of the comment. The
+      # leading space is not required for some RDoc special syntax,
+      # like #++, #--, #:nodoc, etc.
+      class LeadingCommentSpace < Cop
+        MSG = 'Missing space after #.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          comments.each do |comment|
+            if comment.text =~ /^#+[^#\s:+-]/
+              unless comment.text.start_with?('#!') && comment.loc.line == 1
+                add_offence(:convention, comment.loc, MSG)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of the line continuation character.
+      #
+      # This check has to be refined or retired, since it doesn't make a lot
+      # of sense without inspection of its context.
+      class LineContinuation < Cop
+        MSG = 'Avoid the use of the line continuation character(\).'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          source.each_with_index do |line, index|
+            if line =~ /.*\\\z/
+              add_offence(:convention,
+                          source_range(source_buffer, source[0...index],
+                                       line.length - 1, 1),
+                          MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks the length of lines in the source code.
+      # The maximum length is configurable.
+      class LineLength < Cop
+        MSG = 'Line is too long. [%d/%d]'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          source.each_with_index do |line, index|
+            max = LineLength.max
+            if line.length > max
+              message = sprintf(MSG, line.length, max)
+              add_offence(:convention,
+                          source_range(source_buffer, source[0...index], max,
+                                       line.length - max),
+                          message)
+            end
+          end
+        end
+
+        def self.max
+          LineLength.config['Max']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop makes sure that all methods and variables use
+      # snake_case for their names. Some special arrangements have to be
+      # made for operator methods.
+      class MethodAndVariableSnakeCase < Cop
+        MSG = 'Use snake_case for methods and variables.'
+        SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
+
+        # http://phrogz.net/programmingruby/language.html#table_18.4
+        OPERATOR_METHODS = %w(
+          | ^ & <=> == === =~ > >= < <= << >>
+          + - * / % ** ~ +@ -@ [] []= ` ! != !~
+        ).map(&:to_sym)
+
+        def inspect(source_buffer, source, tokens, node, comments)
+          return unless node
+          on_node([:def, :defs, :lvasgn, :ivasgn, :send], node) do |n|
+            name = case n.type
+                   when :def
+                     name_of_instance_method(n)
+                   when :defs
+                     name_of_singleton_method(n)
+                   when :lvasgn, :ivasgn
+                     name_of_variable(n)
+                   when :send
+                     name_of_setter(n)
+                   end
+
+            next unless name
+            next if name =~ SNAKE_CASE || OPERATOR_METHODS.include?(name)
+
+            add_offence(:convention, n.location.expression, MSG)
+          end
+        end
+
+        def name_of_instance_method(def_node)
+          def_node.children.first
+        end
+
+        def name_of_singleton_method(defs_node)
+          defs_node.children[1]
+        end
+
+        def name_of_variable(vasgn_node)
+          vasgn_node.children.first
+        end
+
+        def name_of_setter(send_node)
+          receiver, method_name = *send_node
+          return nil unless receiver && receiver.type == :self
+          return nil unless method_name.to_s.end_with?('=')
+          method_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for unwanted parentheses in parameterless method calls.
+      class MethodCallParentheses < Cop
+        MSG = 'Do not use parentheses for method calls with no arguments.'
+
+        def on_send(node)
+          _receiver, _method_name, *args = *node
+
+          if args.empty? && node.loc.begin
+            add_offence(:convention, node.loc.begin, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks if the length a method exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      class MethodLength < Cop
+        MSG = 'Method has too many lines. [%d/%d]'
+
+        def on_def(node)
+          check(node)
+
+          super
+        end
+
+        def on_defs(node)
+          check(node)
+
+          super
+        end
+
+        def max_length
+          MethodLength.config['Max']
+        end
+
+        def count_comments?
+          MethodLength.config['CountComments']
+        end
+
+        private
+
+        def check(node)
+          method_length = calculate_length(node.loc.expression.source)
+
+          if method_length > max_length
+            message = sprintf(MSG, method_length, max_length)
+            add_offence(:convention, node.loc.keyword, message)
+          end
+        end
+
+        def calculate_length(source)
+          lines = source.lines.to_a[1...-1]
+
+          return 0 unless lines
+
+          lines.map!(&:strip).reject!(&:empty?)
+
+          lines.reject! { |line| line =~ /^\s*#/ } unless count_comments?
+
+          lines.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of the `then` keyword in multi-line if statements.
+      #
+      # This is considered bad practice:
+      # @example
+      #
+      # if cond then
+      # end
+      #
+      # While if statements can contain `then` on the same line:
+      # @example
+      #
+      # if cond then a
+      # elsif cond then b
+      # end
+      class MultilineIfThen < Cop
+        include IfThenElse
+
+        def offending_line(node)
+          condition, body, else_clause = *node
+          next_thing = if body && body.loc.expression
+                         body.loc.expression.begin
+                       elsif else_clause && else_clause.loc.expression
+                        else_clause.loc.expression.begin
+                       else
+                         node.loc.end # No body, use "end".
+                       end
+          right_after_cond =
+            Parser::Source::Range.new(next_thing.source_buffer,
+                                      condition.loc.expression.end.end_pos,
+                                      next_thing.begin_pos)
+          if right_after_cond.source =~ /\A\s*then\s*(#.*)?\s*\n/
+            node.loc.expression.begin.line
+          end
+        end
+
+        def error_message
+          'Never use then for multi-line if/unless.'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses if the keyword *not* instead of !.
+      class Not < Cop
+        MSG = 'Use ! instead of not.'
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+
+          # not does not take any arguments
+          if args.empty? && method_name == :! &&
+              node.loc.selector.is?('not')
+            add_offence(:convention, node.loc.selector, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for big numeric literals without _ between groups
+      # of digits in them.
+      class NumericLiterals < Cop
+        MSG = 'Add underscores to large numeric literals to ' +
+          'improve their readability.'
+
+        def on_int(node)
+          value, = *node
+
+          if value > 10000 &&
+              node.loc.expression.source.split('.').grep(/\d{6}/).any?
+            add_offence(:convention, node.loc.expression, MSG)
+          end
+        end
+
+        alias_method :on_float, :on_int
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of if/then/else/end on a single line.
+      class OneLineConditional < Cop
+        include IfThenElse
+
+        def offending_line(node)
+          node.loc.expression.line unless node.loc.expression.source =~ /\n/
+        end
+
+        def error_message
+          'Favor the ternary operator (?:) over if/then/else/end constructs.'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop makes sure that certain operator methods have their sole
+      # parameter named *other*.
+      class OpMethod < Cop
+        MSG = 'When defining the %s operator, name its argument *other*.'
+
+        BLACKLISTED = [:+@, :-@, :[], :[]=, :<<]
+
+        TARGET_ARGS = s(:args, s(:arg, :other))
+
+        def on_def(node)
+          name, args, _body = *node
+
+          if name !~ /\A\w/ && !BLACKLISTED.include?(name) &&
+              args.children.size == 1 && args != TARGET_ARGS
+            add_offence(:convention, args.children[0].loc.expression,
+                        sprintf(MSG, name))
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for methods with too many parameters.
+      # The maximum number of parameters in configurable.
+      # On Ruby 2.0+ keyword arguments can optionally
+      # be excluded from the total count.
+      class ParameterLists < Cop
+        MSG = 'Avoid parameter lists longer than %d parameters.'
+
+        def on_args(node)
+          if args_count(node) > max_params
+            add_offence(:convention, node.loc.expression,
+                        sprintf(MSG, max_params))
+          end
+
+          super
+        end
+
+        private
+
+        def args_count(node)
+          if count_keyword_args?
+            node.children.size
+          else
+            node.children.reject { |a| a.type == :kwoptarg }.size
+          end
+        end
+
+        def max_params
+          ParameterLists.config['Max']
+        end
+
+        def count_keyword_args?
+          ParameterLists.config['CountKeywordArgs']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for the presence of superfluous parentheses around the
+      # condition of if/while/until.
+      class ParenthesesAroundCondition < Cop
+        MSG = "Don't use parentheses around the condition of an " +
+          'if/unless/while/until'
+
+        def on_if(node)
+          process_control_op(node)
+
+          super
+        end
+
+        def on_while(node)
+          process_control_op(node)
+
+          super
+        end
+
+        def on_until(node)
+          process_control_op(node)
+
+          super
+        end
+
+        private
+
+        def process_control_op(node)
+          cond, _body = *node
+
+          if cond.type == :begin
+            add_offence(:convention, cond.loc.expression, MSG)
+          end
+        end
+      end
+    end
+  end
+end