sabat-rubocop 0.9.0

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for non-ascii (non-English) characters
+      # in comments.
+      class AsciiComments < Cop
+        MSG = 'Use only ascii symbols in comments.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          comments.each do |comment|
+            if comment.text =~ /[^\x00-\x7f]/
+              add_offence(:convention, comment.loc, MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+# rubocop:disable SymbolName
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for non-ascii characters in indentifier names.
+      class AsciiIdentifiers < Cop
+        MSG = 'Use only ascii symbols in identifiers.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          tokens.each do |t|
+            if t.type == :tIDENTIFIER && t.text =~ /[^\x00-\x7f]/
+              add_offence(:convention, t.pos, MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of Module#attr.
+      class Attr < Cop
+        MSG = 'Do not use `attr`. Use `attr_reader` instead.'
+
+        def on_send(node)
+          if command?(:attr, node)
+            add_offence(:convention, node.loc.selector, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of class variables. Offences
+      # are signaled only on assignment to class variables to
+      # reduced the number of offences that would be reported.
+      class AvoidClassVars < Cop
+        MSG = 'Replace class var %s with a class instance var.'
+
+        def on_cvasgn(node)
+          class_var, = *node
+          add_offence(:convention, node.loc.name, sprintf(MSG, class_var))
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for uses of the *for* keyword.
+      class AvoidFor < Cop
+        MSG = 'Prefer *each* over *for*.'
+
+        def on_for(node)
+          add_offence(:convention, node.loc.keyword, MSG)
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops looks for uses of global variables.
+      # It does not report offences for built-in global variables.
+      class AvoidGlobalVars < Cop
+        MSG = 'Do not introduce global variables.'
+
+        # predefined global variables their English aliases
+        # http://www.zenspider.com/Languages/Ruby/QuickRef.html
+        BUILT_IN_VARS = %w(
+          $: $LOAD_PATH
+          $" $LOADED_FEATURES
+          $0 $PROGRAM_NAME
+          $! $ERROR_INFO
+          $@ $ERROR_POSITION
+          $; $FS $FIELD_SEPARATOR
+          $, $OFS $OUTPUT_FIELD_SEPARATOR
+          $/ $RS $INPUT_RECORD_SEPARATOR
+          $\\ $ORS $OUTPUT_RECORD_SEPARATOR
+          $. $NR $INPUT_LINE_NUMBER
+          $_ $LAST_READ_LINE
+          $> $DEFAULT_OUTPUT
+          $< $DEFAULT_INPUT
+          $$ $PID $PROCESS_ID
+          $? $CHILD_STATUS
+          $~ $LAST_MATCH_INFO
+          $= $IGNORECASE
+          $* $ARGV
+          $& $MATCH
+          $` $PREMATCH
+          $' $POSTMATCH
+          $+ $LAST_PAREN_MATCH
+          $stdin $stdout $stderr
+          $DEBUG $FILENAME $VERBOSE
+          $-0 $-a $-d $-F $-i $-I $-l $-p $-v $-w
+        )
+
+        def on_gvar(node)
+          check(node)
+
+          super
+        end
+
+        def on_gvasgn(node)
+          check(node)
+
+          super
+        end
+
+        def check(node)
+          global_var, = *node
+
+          unless BUILT_IN_VARS.include?(global_var.to_s)
+            add_offence(:convention,
+                        node.loc.name,
+                        MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for uses of Perl-style regexp match
+      # backreferences like $1, $2, etc.
+      class AvoidPerlBackrefs < Cop
+        def on_nth_ref(node)
+          backref, = *node
+
+          add_offence(:convention,
+                      node.loc.expression,
+                      "Prefer the use of MatchData over $#{backref}.")
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for uses of Perl-style global variables.
+      class AvoidPerlisms < Cop
+        PREFERRED_VARS = {
+          '$:' => '$LOAD_PATH',
+          '$"' => '$LOADED_FEATURES',
+          '$0' => '$PROGRAM_NAME',
+          '$!' => '$ERROR_INFO from English library',
+          '$@' => '$ERROR_POSITION from English library',
+          '$;' => '$FS or $FIELD_SEPARATOR from English library',
+          '$,' => '$OFS or $OUTPUT_FIELD_SEPARATOR from English library',
+          '$/' => '$RS or $INPUT_RECORD_SEPARATOR from English library',
+          '$\\' => '$ORS or $OUTPUT_RECORD_SEPARATOR from English library',
+          '$.' => '$NR or $INPUT_LINE_NUMBER from English library',
+          '$_' => '$LAST_READ_LINE from English library',
+          '$>' => '$DEFAULT_OUTPUT from English library',
+          '$<' => '$DEFAULT_INPUT from English library',
+          '$$' => '$PID or $PROCESS_ID from English library',
+          '$?' => '$CHILD_STATUS from English library',
+          '$~' => '$LAST_MATCH_INFO from English library',
+          '$=' => '$IGNORECASE from English library',
+          '$*' => '$ARGV from English library or ARGV constant',
+          '$&' => '$MATCH from English library',
+          '$`' => '$PREMATCH from English library',
+          '$\'' => '$POSTMATCH from English library',
+          '$+' => '$LAST_PAREN_MATCH from English library'
+        }
+
+        def on_gvar(node)
+          global_var, = *node
+          global_var = global_var.to_s
+
+          if PREFERRED_VARS[global_var]
+            add_offence(
+              :convention,
+              node.loc.expression,
+              "Prefer #{PREFERRED_VARS[global_var]} over #{global_var}."
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for BEGIN blocks.
+      class BeginBlock < Cop
+        MSG = 'Avoid the use of BEGIN blocks.'
+
+        def on_preexe(node)
+          add_offence(:convention, node.loc.keyword, MSG)
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for uses of block comments (=begin...=end).
+      class BlockComments < Cop
+        MSG = 'Do not use block comments.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          comments.each do |comment|
+            if comment.text.start_with?('=begin')
+              add_offence(:convention, comment.loc, MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for excessive nesting of conditional and looping
+      # constructs. Despite the cop's name, blocks are not considered as a
+      # extra level of nesting.
+      #
+      # The maximum level of nesting allowed is configurable.
+      class BlockNesting < Cop
+        NESTING_BLOCKS = [:case, :if, :while, :while_post, :until, :until_post,
+                          :for, :resbody]
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          return unless ast
+          max = BlockNesting.config['Max']
+          check_nesting_level(ast, max, 0)
+        end
+
+        private
+
+        def check_nesting_level(node, max, current_level)
+          if NESTING_BLOCKS.include?(node.type)
+            unless node.loc.respond_to?(:keyword) &&
+                node.loc.keyword.is?('elsif')
+              current_level += 1
+            end
+            if current_level == max + 1
+              add_offence(:convention, node.location.expression, message(max))
+              return
+            end
+          end
+          node.children.each do |child|
+            if child.is_a?(Parser::AST::Node)
+              check_nesting_level(child, max, current_level)
+            end
+          end
+        end
+
+        def message(max)
+          "Avoid more than #{max} levels of block nesting."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# 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 Blocks < Cop
+        MULTI_LINE_MSG = 'Avoid using {...} for multi-line blocks.'
+        SINGLE_LINE_MSG = 'Prefer {...} over do...end for single-line blocks.'
+
+        def on_block(node)
+          block_length = Util.block_length(node)
+          block_begin = node.loc.begin.source
+
+          if block_length > 0 && block_begin == '{'
+            add_offence(:convention, node.loc.begin, MULTI_LINE_MSG)
+          elsif block_length == 0 && block_begin != '{'
+            add_offence(:convention, node.loc.begin, SINGLE_LINE_MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of the case equality operator(===).
+      class CaseEquality < Cop
+        MSG = 'Avoid the use of the case equality operator(===).'
+
+        def on_send(node)
+          _receiver, method_name, *_args = *node
+
+          if method_name == :===
+            add_offence(:convention, node.loc.selector, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether the *when*s of a *case* expression
+      # are indented as deep as its *case* keyword.
+      #
+      # It will register a separate offence for each misaligned *when*.
+      class CaseIndentation < Cop
+        MSG = 'Indent when as deep as case.'
+
+        def on_case(case_node)
+          _condition, *whens, _else = *case_node
+
+          case_column = case_node.location.keyword.column
+
+          whens.each do |when_node|
+            pos = when_node.loc.keyword
+            add_offence(:convention, pos, MSG) if pos.column != case_column
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of the character literal ?x.
+      class CharacterLiteral < Cop
+        MSG = 'Do not use the character literal - use string literal instead.'
+
+        def on_str(node)
+          # Constants like __FILE__ are handled as strings,
+          # but don't respond to begin.
+          return unless node.loc.respond_to?(:begin)
+
+          # we don't register an offence for things like ?\C-\M-d
+          if node.loc.begin.is?('?') && node.loc.expression.source.size < 4
+            add_offence(:convention, node.loc.expression, MSG)
+            do_autocorrect(node)
+          end
+        end
+
+        alias_method :on_dstr, :ignore_node
+        alias_method :on_regexp, :ignore_node
+
+        def autocorrect_action(node)
+          string = node.loc.expression.source[1..-1]
+
+          if string.length == 1 # normal character
+            replace(node.loc.expression, "'#{string}'")
+          elsif string.length == 2 # special character like \n
+            replace(node.loc.expression, %Q("#{string}"))
+          end
+        end
+      end
+    end
+  end
+end