andypike/rectify

View on GitHub
lib/rectify/form.rb

Summary

Maintainability
A
2 hrs
Test Coverage

Class Form has 24 methods (exceeds 20 allowed). Consider refactoring.
Open

  class Form
    include Virtus.model
    include ActiveModel::Validations

    attr_reader :context
Severity: Minor
Found in lib/rectify/form.rb - About 2 hrs to fix

    Rectify::Form#with_context has approx 7 statements
    Open

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

    A method with Too Many Statements is any method that has a large number of lines.

    Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

    So the following method would score +6 in Reek's statement-counting algorithm:

    def parse(arg, argv, &error)
      if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
        return nil, block, nil                                         # +1
      end
      opt = (val = parse_arg(val, &error))[1]                          # +2
      val = conv_arg(*val)                                             # +3
      if opt and !arg
        argv.shift                                                     # +4
      else
        val[0] = nil                                                   # +5
      end
      val                                                              # +6
    end

    (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

    Rectify::Form#valid? has approx 7 statements
    Open

        def valid?(options = {})
    Severity: Minor
    Found in lib/rectify/form.rb by reek

    A method with Too Many Statements is any method that has a large number of lines.

    Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

    So the following method would score +6 in Reek's statement-counting algorithm:

    def parse(arg, argv, &error)
      if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
        return nil, block, nil                                         # +1
      end
      opt = (val = parse_arg(val, &error))[1]                          # +2
      val = conv_arg(*val)                                             # +3
      if opt and !arg
        argv.shift                                                     # +4
      else
        val[0] = nil                                                   # +5
      end
      val                                                              # +6
    end

    (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

    Rectify::Form#array_attributes_that_respond_to manually dispatches method call
    Open

            .select { |f| f.respond_to?(message) }
    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::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::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#attributes_that_respond_to manually dispatches method call
    Open

            .select { |f| f.respond_to?(message) }
    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::Form#with_context calls 'f.with_context(context)' 2 times
    Open

            .each { |f| f.with_context(context) }
    
          array_attributes_that_respond_to(:with_context)
            .each { |f| f.with_context(context) }
    Severity: Minor
    Found in lib/rectify/form.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    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::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::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::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.

    Rectify::Form#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::Form#with_context has the variable name 'f'
    Open

            .each { |f| f.with_context(context) }
    
          array_attributes_that_respond_to(:with_context)
            .each { |f| f.with_context(context) }
    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.

    There are no issues that match your filters.

    Category
    Status