class Ameba::Rule::Typing::MethodParameterTypeRestriction

Overview

A rule that enforces method parameters have type restrictions, with optional enforcement of block parameters.

For example, this is considered invalid:

def add(a, b)
  a + b
end

And this is considered valid:

def add(a : String, b : String)
  a + b
end

When the config options PrivateMethods and ProtectedMethods are true, this rule is also applied to private and protected methods, respectively.

The BlockParameters configuration option will extend this to block parameters, where these are invalid:

def exec(&)
end

def exec(&block)
end

And this is valid:

def exec(&block : String -> String)
  yield "cmd"
end

The config option DefaultValue controls whether this rule applies to parameters that have a default value.

YAML configuration example:

Typing/MethodParameterTypeRestriction:
  Enabled: true
  DefaultValue: false
  BlockParameters: false
  PrivateMethods: false
  ProtectedMethods: false

Included Modules

Defined in:

ameba/rule/typing/method_parameter_type_restriction.cr

Constant Summary

MSG = "Method parameter should have a type restriction"

Constructors

Class Method Summary

Instance Method Summary

Instance methods inherited from class Ameba::Rule::Base

==(other) ==, catch(source : Source) catch, excluded?(source) excluded?, group group, hash hash, name name, special? special?, test(source : Source, node : Crystal::ASTNode, *opts)
test(source : Source) test

Class methods inherited from class Ameba::Rule::Base

default_severity : Ameba::Severity default_severity

Macros inherited from class Ameba::Rule::Base

issue_for(*args, **kwargs, &block) issue_for

Macros inherited from module Ameba::Config::RuleConfig

properties(&block) properties

Constructor Detail

def self.new(ctx : YAML::ParseContext, node : YAML::Nodes::Node) #

def self.new(config = nil) #

A rule that enforces method parameters have type restrictions, with optional enforcement of block parameters.

For example, this is considered invalid:

def add(a, b)
  a + b
end

And this is considered valid:

def add(a : String, b : String)
  a + b
end

When the config options PrivateMethods and ProtectedMethods are true, this rule is also applied to private and protected methods, respectively.

The BlockParameters configuration option will extend this to block parameters, where these are invalid:

def exec(&)
end

def exec(&block)
end

And this is valid:

def exec(&block : String -> String)
  yield "cmd"
end

The config option DefaultValue controls whether this rule applies to parameters that have a default value.

YAML configuration example:

Typing/MethodParameterTypeRestriction:
  Enabled: true
  DefaultValue: false
  BlockParameters: false
  PrivateMethods: false
  ProtectedMethods: false

[View source]

Class Method Detail

def self.parsed_doc : String | Nil #

Returns documentation for this rule, if there is any.

module Ameba
  # This is a test rule.
  # Does nothing.
  class MyRule < Ameba::Rule::Base
    def test(source)
    end
  end
end

MyRule.parsed_doc # => "This is a test rule.\nDoes nothing."

Instance Method Detail

def block_parameters=(block_parameters : Bool) #

def block_parameters? : Bool #

def default_value=(default_value : Bool) #

def default_value? : Bool #

def description : String #

def description=(description : String) #

def enabled=(enabled : Bool) #

def enabled? : Bool #

def excluded : Array(String) | Nil #

def excluded=(excluded : Array(String) | Nil) #

def private_methods=(private_methods : Bool) #

def private_methods? : Bool #

def protected_methods=(protected_methods : Bool) #

def protected_methods? : Bool #

def severity : Ameba::Severity #

def severity=(severity : Ameba::Severity) #

def since_version : SemanticVersion | Nil #

[View source]
def since_version=(since_version : String) #

def test(source, node : Crystal::Def) #

[View source]