plentz/lol_dba

View on GitHub

Showing 83 of 83 total issues

LolDba::BelongsTo#non_polymorphic_fk manually dispatches method call
Open

      foreign_key ||= if reflection_options.respond_to?(:primary_key_name)

Reek reports a Manual Dispatch smell if it finds source code that manually checks whether an object responds to a method before that method is called. Manual dispatch is a type of Simulated Polymorphism which leads to code that is harder to reason about, debug, and refactor.

Example

class MyManualDispatcher
  attr_reader :foo

  def initialize(foo)
    @foo = foo
  end

  def call
    foo.bar if foo.respond_to?(:bar)
  end
end

Reek would emit the following warning:

test.rb -- 1 warning:
  [9]: MyManualDispatcher manually dispatches method call (ManualDispatch)

LolDba::ErrorLogging has no descriptive comment
Open

  class ErrorLogging

Classes and modules are the units of reuse and release. It is therefore considered good practice to annotate every class and module with a brief comment outlining its responsibilities.

Example

Given

class Dummy
  # Do things...
end

Reek would emit the following warning:

test.rb -- 1 warning:
  [1]:Dummy has no descriptive comment (IrresponsibleModule)

Fixing this is simple - just an explaining comment:

# The Dummy class is responsible for ...
class Dummy
  # Do things...
end

LolDba has no descriptive comment
Open

module LolDba
Severity: Minor
Found in lib/lol_dba.rb by reek

Classes and modules are the units of reuse and release. It is therefore considered good practice to annotate every class and module with a brief comment outlining its responsibilities.

Example

Given

class Dummy
  # Do things...
end

Reek would emit the following warning:

test.rb -- 1 warning:
  [1]:Dummy has no descriptive comment (IrresponsibleModule)

Fixing this is simple - just an explaining comment:

# The Dummy class is responsible for ...
class Dummy
  # Do things...
end

Complex method LolDba::HasMany#find_association_fk (22.5)
Open

    def find_association_fk
      if (source = reflection_options.options[:source])
        association_reflection = through_reflections[source.to_s]
        return nil if association_reflection.options[:polymorphic]
        get_through_foreign_key(association_reflection.klass, reflection_options)
Severity: Minor
Found in lib/lol_dba/index_finding/has_many.rb by flog

Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

You can read more about ABC metrics or the flog tool

LolDba::SqlGenerator#migrator doesn't depend on instance state (maybe move it to another class?)
Open

    def migrator

A Utility Function is any instance method that has no dependency on the state of the instance.

LolDba::MigrationFormatter#migration_instructions doesn't depend on instance state (maybe move it to another class?)
Open

    def migration_instructions(formated_indexes)

A Utility Function is any instance method that has no dependency on the state of the instance.

LolDba::RelationInspector#get_through_foreign_key doesn't depend on instance state (maybe move it to another class?)
Open

    def get_through_foreign_key(target_class, reflection_options)

A Utility Function is any instance method that has no dependency on the state of the instance.

LolDba::MigrationFormatter#format_index doesn't depend on instance state (maybe move it to another class?)
Open

    def format_index(table_name, key)

A Utility Function is any instance method that has no dependency on the state of the instance.

LolDba::Migration#connection doesn't depend on instance state (maybe move it to another class?)
Open

    def connection

A Utility Function is any instance method that has no dependency on the state of the instance.

LolDba::IndexFinder#self.check_for_indexes performs a nil-check
Open

            unless columns.nil? || reflection_options.options.include?(:class)

A NilCheck is a type check. Failures of NilCheck violate the "tell, don't ask" principle.

Additionally, type checks often mask bigger problems in your source code like not using OOP and / or polymorphism when you should.

Example

Given

class Klass
  def nil_checker(argument)
    if argument.nil?
      puts "argument isn't nil!"
    end
  end
end

Reek would emit the following warning:

test.rb -- 1 warning:
  [3]:Klass#nil_checker performs a nil-check. (NilCheck)

LolDba::SqlGenerator#specific_migration has the variable name 'm'
Open

      migration = migrator.migrations.find { |m| m.version == which.to_i }

An Uncommunicative Variable Name is a variable name that doesn't communicate its intent well enough.

Poor names make it hard for the reader to build a mental picture of what's going on in the code. They can also be mis-interpreted; and they hurt the flow of reading, because the reader must slow down to interpret the names.

Missing top-level class documentation comment.
Open

  class HasMany < RelationInspector

This cop checks for missing top-level documentation of classes and modules. Classes with no body are exempt from the check and so are namespace modules - modules that have nothing in their bodies except classes, other modules, or constant definitions.

The documentation requirement is annulled if the class or module has a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the same for all its children.

Example:

# bad
class Person
  # ...
end

# good
# Description/Explanation of Person class
class Person
  # ...
end

end at 29, 8 is not aligned with if at 25, 22.
Open

        end

This cop checks whether the end keywords are aligned properly.

Three modes are supported through the EnforcedStyleAlignWith configuration parameter:

If it's set to keyword (which is the default), the end shall be aligned with the start of the keyword (if, class, etc.).

If it's set to variable the end shall be aligned with the left-hand-side of the variable assignment, if there is one.

If it's set to start_of_line, the end shall be aligned with the start of the line where the matching keyword appears.

Example: EnforcedStyleAlignWith: keyword (default)

# bad

variable = if true
    end

# good

variable = if true
           end

Example: EnforcedStyleAlignWith: variable

# bad

variable = if true
    end

# good

variable = if true
end

Example: EnforcedStyleAlignWith: startofline

# bad

variable = if true
    end

# good

puts(if true
end)

Useless assignment to variable - foreign_key. Use || instead of ||=.
Open

      foreign_key ||= if reflection_options.respond_to?(:primary_key_name)

This cop 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.

Example:

# bad

def some_method
  some_var = 1
  do_something
end

Example:

# good

def some_method
  some_var = 1
  do_something(some_var)
end

Missing top-level class documentation comment.
Open

  class ErrorLogging

This cop checks for missing top-level documentation of classes and modules. Classes with no body are exempt from the check and so are namespace modules - modules that have nothing in their bodies except classes, other modules, or constant definitions.

The documentation requirement is annulled if the class or module has a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the same for all its children.

Example:

# bad
class Person
  # ...
end

# good
# Description/Explanation of Person class
class Person
  # ...
end

Missing top-level class documentation comment.
Open

  class MigrationMocker

This cop checks for missing top-level documentation of classes and modules. Classes with no body are exempt from the check and so are namespace modules - modules that have nothing in their bodies except classes, other modules, or constant definitions.

The documentation requirement is annulled if the class or module has a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the same for all its children.

Example:

# bad
class Person
  # ...
end

# good
# Description/Explanation of Person class
class Person
  # ...
end

required_ruby_version (2.0, declared in lol_dba.gemspec) and TargetRubyVersion (2.1, declared in .rubocop.yml) should be equal.
Open

  s.required_ruby_version = '>= 2.0.0'
Severity: Minor
Found in lol_dba.gemspec by rubocop

Checks that required_ruby_version of gemspec and TargetRubyVersion of .rubocop.yml are equal. Thereby, RuboCop to perform static analysis working on the version required by gemspec.

Example:

# When `TargetRubyVersion` of .rubocop.yml is `2.3`.

# bad
Gem::Specification.new do |spec|
  spec.required_ruby_version = '>= 2.2.0'
end

# bad
Gem::Specification.new do |spec|
  spec.required_ruby_version = '>= 2.4.0'
end

# good
Gem::Specification.new do |spec|
  spec.required_ruby_version = '>= 2.3.0'
end

# good
Gem::Specification.new do |spec|
  spec.required_ruby_version = '>= 2.3'
end

# good
Gem::Specification.new do |spec|
  spec.required_ruby_version = ['>= 2.3.0', '< 2.5.0']
end

Line is too long. [119/100]
Open

  s.summary = 'A small package of rake tasks to track down missing database indexes and generate sql migration scripts'
Severity: Minor
Found in lol_dba.gemspec by rubocop

Useless assignment to variable - index_name.
Open

      index_name = [association_fk, foreign_key].map(&:to_s).sort

This cop 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.

Example:

# bad

def some_method
  some_var = 1
  do_something
end

Example:

# good

def some_method
  some_var = 1
  do_something(some_var)
end

Missing top-level class documentation comment.
Open

  class MigrationFormatter

This cop checks for missing top-level documentation of classes and modules. Classes with no body are exempt from the check and so are namespace modules - modules that have nothing in their bodies except classes, other modules, or constant definitions.

The documentation requirement is annulled if the class or module has a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the same for all its children.

Example:

# bad
class Person
  # ...
end

# good
# Description/Explanation of Person class
class Person
  # ...
end
Severity
Category
Status
Source
Language