ManageIQ/manageiq-gems-pending

Checks for private or protected access modifiers which are applied to a singleton method. These access modifiers do not make singleton methods private/protected. private_class_method can be used for that.

Example:

# bad
 
class C
  private
 
  def self.method
    puts 'hi'
  end
end

Example:

# good
 
class C
  def self.method
    puts 'hi'
  end
 
  private_class_method :method
end

Example:

# good
 
class C
  class << self
    private
 
    def method
      puts 'hi'
    end
  end
end

Checks for the presence of constructors and lifecycle callbacks without calls to super.

This cop does not consider method_missing (and respond_to_missing?) because in some cases it makes sense to overtake what is considered a missing method. In other cases, the theoretical ideal handling could be challenging or verbose for no actual gain.

Autocorrection is not supported because the position of super cannot be determined automatically.

Object and BasicObject are allowed by this cop because of their stateless nature. However, sometimes you might want to allow other parent classes from this cop, for example in the case of an abstract class that is not meant to be called with super. In those cases, you can use the AllowedParentClasses option to specify which classes should be allowed in addition to Object and BasicObject.

Example:

# bad
class Employee < Person
  def initialize(name, salary)
    @salary = salary
  end
end
 
# good
class Employee < Person
  def initialize(name, salary)
    super(name)
    @salary = salary
  end
end
 
# bad
Employee = Class.new(Person) do
  def initialize(name, salary)
    @salary = salary
  end
end
 
# good
Employee = Class.new(Person) do
  def initialize(name, salary)
    super(name)
    @salary = salary
  end
end
 
# bad
class Parent
  def self.inherited(base)
    do_something
  end
end
 
# good
class Parent
  def self.inherited(base)
    super
    do_something
  end
end
 
# good
class ClassWithNoParent
  def initialize
    do_something
  end
end

Example: AllowedParentClasses: [MyAbstractClass]

# good
class MyConcreteClass < MyAbstractClass
  def initialize
    do_something
  end
end

Checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

assigned but unused variable - foo

Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

NOTE: Given the assignment foo = 1, bar = 2, removing unused variables can lead to a syntax error, so this case is not autocorrected.

Safety:

This cop's autocorrection is unsafe because removing assignment from operator assignment can cause NameError if this assignment has been used to declare local variable. For example, replacing a ||= 1 to a || 1 may cause "undefined local variable or method `a' for main:Object (NameError)".

Example:

# bad
 
def some_method
  some_var = 1
  do_something
end

Example:

# good
 
def some_method
  some_var = 1
  do_something(some_var)
end

Checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

assigned but unused variable - foo

Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

NOTE: Given the assignment foo = 1, bar = 2, removing unused variables can lead to a syntax error, so this case is not autocorrected.

Safety:

This cop's autocorrection is unsafe because removing assignment from operator assignment can cause NameError if this assignment has been used to declare local variable. For example, replacing a ||= 1 to a || 1 may cause "undefined local variable or method `a' for main:Object (NameError)".

Example:

# bad
 
def some_method
  some_var = 1
  do_something
end

Example:

# good
 
def some_method
  some_var = 1
  do_something(some_var)
end

Checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

assigned but unused variable - foo

Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

NOTE: Given the assignment foo = 1, bar = 2, removing unused variables can lead to a syntax error, so this case is not autocorrected.

Safety:

This cop's autocorrection is unsafe because removing assignment from operator assignment can cause NameError if this assignment has been used to declare local variable. For example, replacing a ||= 1 to a || 1 may cause "undefined local variable or method `a' for main:Object (NameError)".

Example:

# bad
 
def some_method
  some_var = 1
  do_something
end

Example:

# good
 
def some_method
  some_var = 1
  do_something(some_var)
end

Checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

assigned but unused variable - foo

Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

NOTE: Given the assignment foo = 1, bar = 2, removing unused variables can lead to a syntax error, so this case is not autocorrected.

Safety:

This cop's autocorrection is unsafe because removing assignment from operator assignment can cause NameError if this assignment has been used to declare local variable. For example, replacing a ||= 1 to a || 1 may cause "undefined local variable or method `a' for main:Object (NameError)".

Example:

# bad
 
def some_method
  some_var = 1
  do_something
end

Example:

# good
 
def some_method
  some_var = 1
  do_something(some_var)
end

Checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

assigned but unused variable - foo

Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

NOTE: Given the assignment foo = 1, bar = 2, removing unused variables can lead to a syntax error, so this case is not autocorrected.

Safety:

This cop's autocorrection is unsafe because removing assignment from operator assignment can cause NameError if this assignment has been used to declare local variable. For example, replacing a ||= 1 to a || 1 may cause "undefined local variable or method `a' for main:Object (NameError)".

Example:

# bad
 
def some_method
  some_var = 1
  do_something
end

Example:

# good
 
def some_method
  some_var = 1
  do_something(some_var)
end

Checks for private or protected access modifiers which are applied to a singleton method. These access modifiers do not make singleton methods private/protected. private_class_method can be used for that.

Example:

# bad
 
class C
  private
 
  def self.method
    puts 'hi'
  end
end

Example:

# good
 
class C
  def self.method
    puts 'hi'
  end
 
  private_class_method :method
end

Example:

# good
 
class C
  class << self
    private
 
    def method
      puts 'hi'
    end
  end
end

Checks for operators, variables, literals, lambda, proc and nonmutating methods used in void context.

Example: CheckForMethodsWithNoSideEffects: false (default)

# bad
def some_method
  some_num * 10
  do_something
end
 
def some_method(some_var)
  some_var
  do_something
end

Example: CheckForMethodsWithNoSideEffects: true

# bad
def some_method(some_array)
  some_array.sort
  do_something(some_array)
end
 
# good
def some_method
  do_something
  some_num * 10
end
 
def some_method(some_var)
  do_something
  some_var
end
 
def some_method(some_array)
  some_array.sort!
  do_something(some_array)
end

Checks for private or protected access modifiers which are applied to a singleton method. These access modifiers do not make singleton methods private/protected. private_class_method can be used for that.

Example:

# bad
 
class C
  private
 
  def self.method
    puts 'hi'
  end
end

Example:

# good
 
class C
  def self.method
    puts 'hi'
  end
 
  private_class_method :method
end

Example:

# good
 
class C
  class << self
    private
 
    def method
      puts 'hi'
    end
  end
end

Checks for non-atomic file operation. And then replace it with a nearly equivalent and atomic method.

These can cause problems that are difficult to reproduce, especially in cases of frequent file operations in parallel, such as test runs with parallel_rspec.

For examples: creating a directory if there is none, has the following problems

An exception occurs when the directory didn't exist at the time of exist?, but someone else created it before mkdir was executed.

Subsequent processes are executed without the directory that should be there when the directory existed at the time of exist?, but someone else deleted it shortly afterwards.

Safety:

This cop is unsafe, because autocorrection change to atomic processing. The atomic processing of the replacement destination is not guaranteed to be strictly equivalent to that before the replacement.

Example:

# bad - race condition with another process may result in an error in `mkdir`
unless Dir.exist?(path)
  FileUtils.mkdir(path)
end
 
# good - atomic and idempotent creation
FileUtils.mkdir_p(path)
 
# bad - race condition with another process may result in an error in `remove`
if File.exist?(path)
  FileUtils.remove(path)
end
 
# good - atomic and idempotent removal
FileUtils.rm_f(path)

Checks for the use of Kernel#open and URI.open with dynamic data.

Kernel#open and URI.open enable not only file access but also process invocation by prefixing a pipe symbol (e.g., open("| ls")). So, it may lead to a serious security risk by using variable input to the argument of Kernel#open and URI.open. It would be better to use File.open, IO.popen or URI.parse#open explicitly.

NOTE: open and URI.open with literal strings are not flagged by this cop.

Safety:

This cop could register false positives if open is redefined in a class and then used without a receiver in that class.

Example:

# bad
open(something)
open("| #{something}")
URI.open(something)
 
# good
File.open(something)
IO.popen(something)
URI.parse(something).open
 
# good (literal strings)
open("foo.text")
open("| foo")
URI.open("http://example.com")

Checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

assigned but unused variable - foo

Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

NOTE: Given the assignment foo = 1, bar = 2, removing unused variables can lead to a syntax error, so this case is not autocorrected.

Safety:

This cop's autocorrection is unsafe because removing assignment from operator assignment can cause NameError if this assignment has been used to declare local variable. For example, replacing a ||= 1 to a || 1 may cause "undefined local variable or method `a' for main:Object (NameError)".

Example:

# bad
 
def some_method
  some_var = 1
  do_something
end

Example:

# good
 
def some_method
  some_var = 1
  do_something(some_var)
end

Checks for rescue blocks targeting the Exception class.

Example:

# bad
 
begin
  do_something
rescue Exception
  handle_exception
end

Example:

# good
 
begin
  do_something
rescue ArgumentError
  handle_exception
end

This cop identifies the use of a &block parameter and block.call where yield would do just as well.

Example:

# bad
def method(&block)
  block.call
end
def another(&func)
  func.call 1, 2, 3
end
 
# good
def method
  yield
end
def another
  yield 1, 2, 3
end

Checks for the use of local variable names from an outer scope in block arguments or block-local variables. This mirrors the warning given by ruby -cw prior to Ruby 2.6: "shadowing outer local variable - foo".

NOTE: Shadowing of variables in block passed to Ractor.new is allowed because Ractor should not access outer variables. eg. following style is encouraged:

```ruby
worker_id, pipe = env
Ractor.new(worker_id, pipe) do |worker_id, pipe|
end
```

Example:

# bad
 
def some_method
  foo = 1
 
  2.times do |foo| # shadowing outer `foo`
    do_something(foo)
  end
end

Example:

# good
 
def some_method
  foo = 1
 
  2.times do |bar|
    do_something(bar)
  end
end