Sign upLogin

ManageIQ/manageiq-smartstate

View on GitHub
Star
lib/fs/ext4/inode.rb

Summary

Maintainability
C
1 day
Test Coverage
D
64%

Class Inode has 39 methods (exceeds 20 allowed). Consider refactoring.
Open

  class Inode
    # Bits 0 to 8 of file mode.
    PF_O_EXECUTE  = 0x0001  # owner execute
    PF_O_WRITE    = 0x0002  # owner write
    PF_O_READ     = 0x0004  # owner read
Severity: Minor
Found in lib/fs/ext4/inode.rb - About 5 hrs to fix

File inode.rb has 374 lines of code (exceeds 250 allowed). Consider refactoring.
Open

require 'fs/ext4/directory_entry'
require 'fs/ext4/extent'
require 'fs/ext4/extent_header'
require 'fs/ext4/extent_index'
Severity: Minor
Found in lib/fs/ext4/inode.rb - About 5 hrs to fix

Wrap expressions with varying precedence with parentheses to avoid ambiguity.
Open

      1.upto(extent.length) { |i| block_pointers << extent.start + i - 1 }
Severity: Minor
Found in lib/fs/ext4/inode.rb by rubocop

Looks for expressions containing multiple binary operators where precedence is ambiguous due to lack of parentheses. For example, in 1 + 2 * 3, the multiplication will happen before the addition, but lexically it appears that the addition will happen first.

The cop does not consider unary operators (ie. !a or -b) or comparison operators (ie. a =~ b) because those are not ambiguous.

NOTE: Ranges are handled by Lint/AmbiguousRange.

Example:

# bad
a + b * c
a || b && c
a ** b + c

# good (different precedence)
a + (b * c)
a || (b && c)
(a ** b) + c

# good (same precedence)
a + b + c
a * b / c % d

Wrap expressions with varying precedence with parentheses to avoid ambiguity.
Open

          extent = Extent.new(@in['data'][SIZEOF_EXTENT_HEADER + SIZEOF_EXTENT * (i - 1), SIZEOF_EXTENT])
Severity: Minor
Found in lib/fs/ext4/inode.rb by rubocop

Looks for expressions containing multiple binary operators where precedence is ambiguous due to lack of parentheses. For example, in 1 + 2 * 3, the multiplication will happen before the addition, but lexically it appears that the addition will happen first.

The cop does not consider unary operators (ie. !a or -b) or comparison operators (ie. a =~ b) because those are not ambiguous.

NOTE: Ranges are handled by Lint/AmbiguousRange.

Example:

# bad
a + b * c
a || b && c
a ** b + c

# good (different precedence)
a + (b * c)
a || (b && c)
(a ** b) + c

# good (same precedence)
a + b + c
a * b / c % d

Useless assignment to variable - end_block. Use _ or _end_block as a variable name to indicate that it won't be used.
Open

      start_block, start_byte, end_block, end_byte, nblocks = pos_to_block(@pos, nbytes)
Severity: Minor
Found in lib/fs/ext4/inode.rb by rubocop

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

Useless assignment to variable - end_byte. Use _ or _end_byte as a variable name to indicate that it won't be used.
Open

      start_block, start_byte, end_block, end_byte, nblocks = pos_to_block(@pos, nbytes)
Severity: Minor
Found in lib/fs/ext4/inode.rb by rubocop

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

Wrap expressions with varying precedence with parentheses to avoid ambiguity.
Open

            extent = Extent.new(leaf_block[SIZEOF_EXTENT_HEADER + SIZEOF_EXTENT * (j - 1), SIZEOF_EXTENT])
Severity: Minor
Found in lib/fs/ext4/inode.rb by rubocop

Looks for expressions containing multiple binary operators where precedence is ambiguous due to lack of parentheses. For example, in 1 + 2 * 3, the multiplication will happen before the addition, but lexically it appears that the addition will happen first.

The cop does not consider unary operators (ie. !a or -b) or comparison operators (ie. a =~ b) because those are not ambiguous.

NOTE: Ranges are handled by Lint/AmbiguousRange.

Example:

# bad
a + b * c
a || b && c
a ** b + c

# good (different precedence)
a + (b * c)
a || (b && c)
(a ** b) + c

# good (same precedence)
a + b + c
a * b / c % d

Wrap expressions with varying precedence with parentheses to avoid ambiguity.
Open

          extent_index    = ExtentIndex.new(@in['data'][SIZEOF_EXTENT_HEADER + SIZEOF_EXTENT_INDEX * (i - 1), SIZEOF_EXTENT_INDEX])
Severity: Minor
Found in lib/fs/ext4/inode.rb by rubocop

Looks for expressions containing multiple binary operators where precedence is ambiguous due to lack of parentheses. For example, in 1 + 2 * 3, the multiplication will happen before the addition, but lexically it appears that the addition will happen first.

The cop does not consider unary operators (ie. !a or -b) or comparison operators (ie. a =~ b) because those are not ambiguous.

NOTE: Ranges are handled by Lint/AmbiguousRange.

Example:

# bad
a + b * c
a || b && c
a ** b + c

# good (different precedence)
a + (b * c)
a || (b && c)
(a ** b) + c

# good (same precedence)
a + b + c
a * b / c % d

There are no issues that match your filters.

Category
Status