andypike/rectify

View on GitHub

Showing 87 of 91 total issues

Rectify::Form has no descriptive comment
Open

  class Form
Severity: Minor
Found in lib/rectify/form.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

Rectify::Form#self.hash_from manually dispatches method call
Open

      params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
Severity: Minor
Found in lib/rectify/form.rb by reek

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)

Rectify::RSpec::DatabaseReporter::QueryInfo has no descriptive comment
Open

      class QueryInfo

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

Rectify::Command#respond_to_missing? manually dispatches method call
Open

      @caller.respond_to?(method_name, include_private)
Severity: Minor
Found in lib/rectify/command.rb by reek

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)

Rectify::BuildFormFromModel has no descriptive comment
Open

  class BuildFormFromModel
Severity: Minor
Found in lib/rectify/build_form_from_model.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

Rectify::Presenter#respond_to_missing? manually dispatches method call
Open

      view_context.respond_to?(method_name, include_private)
Severity: Minor
Found in lib/rectify/presenter.rb by reek

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)

Rectify::SqlQuery has no descriptive comment
Open

  module SqlQuery
Severity: Minor
Found in lib/rectify/sql_query.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

Rectify::ControllerHelpers has no descriptive comment
Open

  module ControllerHelpers
Severity: Minor
Found in lib/rectify/controller_helpers.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

Rectify::FormAttribute#collection_of_form_objects? manually dispatches method call
Open

      collection? && element_class.respond_to?(:from_model)
Severity: Minor
Found in lib/rectify/form_attribute.rb by reek

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)

Rectify::RSpec::DatabaseReporter has no descriptive comment
Open

    class DatabaseReporter

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

Rectify::RSpec::Helpers#stub_form doesn't depend on instance state (maybe move it to another class?)
Open

      def stub_form(attributes)
Severity: Minor
Found in lib/rectify/rspec/helpers.rb by reek

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

Rectify::Form#attributes_with_values performs a nil-check
Open

      attributes.reject { |attribute| public_send(attribute).nil? }
Severity: Minor
Found in lib/rectify/form.rb by reek

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)

Rectify::FormatAttributesHash#underscore_key doesn't depend on instance state (maybe move it to another class?)
Open

    def underscore_key(k)
Severity: Minor
Found in lib/rectify/format_attributes_hash.rb by reek

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

Rectify::Form#map_model has unused parameter 'model'
Open

    def map_model(model)
Severity: Minor
Found in lib/rectify/form.rb by reek

Unused Parameter refers to methods with parameters that are unused in scope of the method.

Having unused parameters in a method is code smell because leaving dead code in a method can never improve the method and it makes the code confusing to read.

Example

Given:

class Klass
  def unused_parameters(x,y,z)
    puts x,y # but not z
  end
end

Reek would emit the following warning:

[2]:Klass#unused_parameters has unused parameter 'z' (UnusedParameters)

Rectify::Query#self.merge has the variable name 'a'
Open

      queries.reduce(NullQuery.new) { |a, e| a.merge(e) }
Severity: Minor
Found in lib/rectify/query.rb by reek

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.

Rectify::Form#array_attributes_that_respond_to has the variable name 'f'
Open

        .select { |f| f.respond_to?(message) }
Severity: Minor
Found in lib/rectify/form.rb by reek

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.

Rectify::FormatAttributesHash#underscore_key has the parameter name 'k'
Open

    def underscore_key(k)
Severity: Minor
Found in lib/rectify/format_attributes_hash.rb by reek

An Uncommunicative Parameter Name is a parameter 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.

Rectify::BuildFormFromModel#matching_attributes has the variable name 'a'
Open

        .select { |a| model.respond_to?(a.name) }
        .map    { |a| FormAttribute.new(a) }
Severity: Minor
Found in lib/rectify/build_form_from_model.rb by reek

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.

Rectify::BuildFormFromModel#build has the variable name 'a'
Open

        matching_attributes.each do |a|
Severity: Minor
Found in lib/rectify/build_form_from_model.rb by reek

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.

Rectify::Form#array_attributes_that_respond_to has the variable name 'a'
Open

        .select { |a| a.is_a?(Array) }
Severity: Minor
Found in lib/rectify/form.rb by reek

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.

Severity
Category
Status
Source
Language