Sign upLogin

dphaener/kanji

View on GitHub
Star
lib/kanji/type/attribute_definer.rb

Summary

Maintainability
A
35 mins
Test Coverage

Method initialize has 5 arguments (exceeds 4 allowed). Consider refactoring.
Open

      def initialize(name, type = nil, description = nil, **kwargs, &block)
Severity: Minor
Found in lib/kanji/type/attribute_definer.rb - About 35 mins to fix

    Redundant self detected.
    Open

            self.instance_eval &block if block_given?
    Severity: Minor
    Found in lib/kanji/type/attribute_definer.rb by rubocop

    This cop checks for redundant uses of self.

    The usage of self is only needed when:

    • Sending a message to same object with zero arguments in presence of a method name clash with an argument or a local variable.

    • Calling an attribute writer to prevent an local variable assignment.

    Note, with using explicit self you can only send messages with public or protected scope, you cannot send private messages this way.

    Note we allow uses of self with operators because it would be awkward otherwise.

    Example:

    # bad
def foo(bar)
  self.baz
end

# good
def foo(bar)
  self.bar  # Resolves name clash with the argument.
end

def foo
  bar = 1
  self.bar  # Resolves name clash with the local variable.
end

def foo
  %w[x y z].select do |bar|
    self.bar == bar  # Resolves name clash with argument of the block.
  end
end

    Ambiguous block operator. Parenthesize the method arguments if it's surely a block operator, or add a whitespace to the right of the & if it should be a binary AND.
    Open

            self.instance_eval &block if block_given?
    Severity: Minor
    Found in lib/kanji/type/attribute_definer.rb by rubocop

    This cop checks for ambiguous operators in the first argument of a method invocation without parentheses.

    Example:

    # bad

# The `*` is interpreted as a splat operator but it could possibly be
# a `*` method invocation (i.e. `do_something.*(some_array)`).
do_something *some_array

    Example:

    # good

# With parentheses, there's no ambiguity.
do_something(*some_array)

    Redundant curly braces around a hash parameter.
    Open

            Attribute.new({
          name: @_name,
          type: @_type,
          description: @_description,
          options: @_options,
    Severity: Minor
    Found in lib/kanji/type/attribute_definer.rb by rubocop

    This cop checks for braces around the last parameter in a method call if the last parameter is a hash. It supports braces, no_braces and context_dependent styles.

    Example: EnforcedStyle: braces

    # The `braces` style enforces braces around all method
# parameters that are hashes.

# bad
some_method(x, y, a: 1, b: 2)

# good
some_method(x, y, {a: 1, b: 2})

    Example: EnforcedStyle: no_braces (default)

    # The `no_braces` style checks that the last parameter doesn't
# have braces around it.

# bad
some_method(x, y, {a: 1, b: 2})

# good
some_method(x, y, a: 1, b: 2)

    Example: EnforcedStyle: context_dependent

    # The `context_dependent` style checks that the last parameter
# doesn't have braces around it, but requires braces if the
# second to last parameter is also a hash literal.

# bad
some_method(x, y, {a: 1, b: 2})
some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)

# good
some_method(x, y, a: 1, b: 2)
some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})

    There are no issues that match your filters.

    Category
    Status