Sign upLogin

znamenica/dneslov

View on GitHub
Star

Showing 2,171 of 2,171 total issues

Do not use spaces between -> and opening brace in lambda literals
Open

   scope :with_covering_names, -> context do
      as = table.table_alias || table.name
      language_codes = [ context[:locales] ].flatten

      selector = self.select_values.dup
Severity: Minor
Found in app/models/memory.rb by rubocop

This cop checks for spaces between -> and opening parameter brace in lambda literals.

Example: EnforcedStyle: requirenospace (default)

# bad
  a = -> (x, y) { x + y }

  # good
  a = ->(x, y) { x + y }

Example: EnforcedStyle: require_space

# bad
  a = ->(x, y) { x + y }

  # good
  a = -> (x, y) { x + y }

Space inside parentheses detected.
Open

      memory_names.join( ' ' )
Severity: Minor
Found in app/models/memory.rb by rubocop

Checks for spaces inside ordinary round parentheses.

Example:

# bad
f( 3)
g = (a + 3 )

# good
f(3)
g = (a + 3)

Missing top-level class documentation comment.
Open

class ItemType < ActiveRecord::Base
Severity: Minor
Found in app/models/item_type.rb by rubocop

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

Omit parentheses for the empty lambda parameters.
Open

   scope :image, ->() do
Severity: Minor
Found in app/models/resource.rb by rubocop

This cop checks for parentheses for empty lambda parameters. Parentheses for empty lambda parameters do not cause syntax errors, but they are redundant.

Example:

# bad
-> () { do_something }

# good
-> { do_something }

# good
-> (arg) { do_something(arg) }

Do not use spaces between -> and opening brace in lambda literals
Open

   scope :with_orders, -> context do
      language_codes = [ context[:locales] ].flatten
      selector = self.select_values.dup
      if self.select_values.dup.empty?
         selector << 'memories.*'
Severity: Minor
Found in app/models/memory.rb by rubocop

This cop checks for spaces between -> and opening parameter brace in lambda literals.

Example: EnforcedStyle: requirenospace (default)

# bad
  a = -> (x, y) { x + y }

  # good
  a = ->(x, y) { x + y }

Example: EnforcedStyle: require_space

# bad
  a = ->(x, y) { x + y }

  # good
  a = -> (x, y) { x + y }

Space inside } missing.
Open

      unscoped.joins(:slug).where(slugs: {text: slug.split(",")})
Severity: Minor
Found in app/models/memory.rb by rubocop

Checks that braces used for hash literals have or don't have surrounding space depending on configuration.

Example: EnforcedStyle: space

# The `space` style enforces that hash literals have
# surrounding space.

# bad
h = {a: 1, b: 2}

# good
h = { a: 1, b: 2 }

Example: EnforcedStyle: no_space

# The `no_space` style enforces that hash literals have
# no surrounding space.

# bad
h = { a: 1, b: 2 }

# good
h = {a: 1, b: 2}

Example: EnforcedStyle: compact

# The `compact` style normally requires a space inside
# hash braces, with the exception that successive left
# braces or right braces are collapsed together in nested hashes.

# bad
h = { a: { b: 2 } }

# good
h = { a: { b: 2 }}

Space inside parentheses detected.
Open

   scope :icons, -> { joins( :slugs ).where( slugs: { text: :обр } ) }
Severity: Minor
Found in app/models/memory.rb by rubocop

Checks for spaces inside ordinary round parentheses.

Example:

# bad
f( 3)
g = (a + 3 )

# good
f(3)
g = (a + 3)

Space inside parentheses detected.
Open

      left_outer_joins(:names, :descriptions).where( "short_name ~* ?", "\\m#{text}.*" ).or(
Severity: Minor
Found in app/models/memory.rb by rubocop

Checks for spaces inside ordinary round parentheses.

Example:

# bad
f( 3)
g = (a + 3 )

# good
f(3)
g = (a + 3)

Space inside parentheses detected.
Open

      memory_names.join( ' ' )
Severity: Minor
Found in app/models/memory.rb by rubocop

Checks for spaces inside ordinary round parentheses.

Example:

# bad
f( 3)
g = (a + 3 )

# good
f(3)
g = (a + 3)

Line is too long. [269/130]
Open

                ON n.bond_to_id = t.name_id AND n.root_id = t.root_id JOIN names nm ON nm.id = n.name_id JOIN names nm_t ON nm_t.id = t.name_id AND nm_t.language_code <> nm.language_code LEFT OUTER JOIN memory_names mn ON n.root_id = mn.nomen_id AND mn.memory_id = 2989
Severity: Minor
Found in app/models/memory.rb by rubocop

Line is too long. [177/130]
Open

              WITH RECURSIVE __names(level,path,id,name_id,name_bind_kind_name,bond_to_id,root_id,name_alphabeth_code,name_language_code,name_text,state_code,mode,feasible) AS (
Severity: Minor
Found in app/models/memory.rb by rubocop

Line is too long. [180/130]
Open

                              #{as}_place_descriptions.text || ' (' || #{as}_place_descriptions.language_code || '_' || #{as}_place_descriptions.alphabeth_code || ')' AS place_name
Severity: Minor
Found in app/models/memory.rb by rubocop

Use the lambda method for multiline lambdas.
Open

   scope :with_value, -> context do
Severity: Minor
Found in app/models/subject.rb by rubocop

This cop (by default) checks for uses of the lambda literal syntax for single line lambdas, and the method call syntax for multiline lambdas. It is configurable to enforce one of the styles for both single line and multiline lambdas as well.

Example: EnforcedStyle: linecountdependent (default)

# bad
f = lambda { |x| x }
f = ->(x) do
      x
    end

# good
f = ->(x) { x }
f = lambda do |x|
      x
    end

Example: EnforcedStyle: lambda

# bad
f = ->(x) { x }
f = ->(x) do
      x
    end

# good
f = lambda { |x| x }
f = lambda do |x|
      x
    end

Example: EnforcedStyle: literal

# bad
f = lambda { |x| x }
f = lambda do |x|
      x
    end

# good
f = ->(x) { x }
f = ->(x) do
      x
    end

Use the lambda method for multiline lambdas.
Open

   scope :in_calendaries, -> calendaries_in do
Severity: Minor
Found in app/models/memory.rb by rubocop

This cop (by default) checks for uses of the lambda literal syntax for single line lambdas, and the method call syntax for multiline lambdas. It is configurable to enforce one of the styles for both single line and multiline lambdas as well.

Example: EnforcedStyle: linecountdependent (default)

# bad
f = lambda { |x| x }
f = ->(x) do
      x
    end

# good
f = ->(x) { x }
f = lambda do |x|
      x
    end

Example: EnforcedStyle: lambda

# bad
f = ->(x) { x }
f = ->(x) do
      x
    end

# good
f = lambda { |x| x }
f = lambda do |x|
      x
    end

Example: EnforcedStyle: literal

# bad
f = lambda { |x| x }
f = lambda do |x|
      x
    end

# good
f = ->(x) { x }
f = ->(x) do
      x
    end

Freeze mutable objects assigned to constants.
Open

   JSONIZE_ATTRS = {
      meta: ->(this) { this.meta.to_json },
   }
Severity: Minor
Found in app/models/subject.rb by rubocop

This cop checks whether some constant value isn't a mutable literal (e.g. array or hash).

Example:

# bad
CONST = [1, 2, 3]

# good
CONST = [1, 2, 3].freeze

Prefer single-quoted strings when you don't need string interpolation or special symbols.
Open

      selector << "kind_titles.text AS _kind_title"
Severity: Minor
Found in app/models/subject.rb by rubocop

Checks if uses of quotes match the configured preference.

Example: EnforcedStyle: single_quotes (default)

# bad
"No special symbols"
"No string interpolation"
"Just text"

# good
'No special symbols'
'No string interpolation'
'Just text'
"Wait! What's #{this}!"

Example: EnforcedStyle: double_quotes

# bad
'Just some text'
'No special chars or interpolation'

# good
"Just some text"
"No special chars or interpolation"
"Every string in #{project} uses double_quotes"

Wrap stabby lambda arguments with parentheses.
Open

   scope :descriptions_for, -> language_code { joins(:descriptions).where(descriptions: { language_code: language_code }) }
Severity: Minor
Found in app/models/item_type.rb by rubocop

Check for parentheses around stabby lambda arguments. There are two different styles. Defaults to require_parentheses.

Example: EnforcedStyle: require_parentheses (default)

# bad
->a,b,c { a + b + c }

# good
->(a,b,c) { a + b + c}

Example: EnforcedStyle: requirenoparentheses

# bad
->(a,b,c) { a + b + c }

# good
->a,b,c { a + b + c}

Missing space after #.
Open

      #TODO add search over names
Severity: Minor
Found in app/models/memory.rb by rubocop

This cop checks whether comments have a leading space after the # denoting the start of the comment. The leading space is not required for some RDoc special syntax, like #++, #--, #:nodoc, =begin- and =end comments, "shebang" directives, or rackup options.

Example:

# bad
#Some comment

# good
# Some comment

Do not use spaces between -> and opening brace in lambda literals
Open

   scope :with_key, -> _ do
      selector = [ 'memories.id AS _key' ]

      select(selector).group('_key').reorder("_key")
   end
Severity: Minor
Found in app/models/memory.rb by rubocop

This cop checks for spaces between -> and opening parameter brace in lambda literals.

Example: EnforcedStyle: requirenospace (default)

# bad
  a = -> (x, y) { x + y }

  # good
  a = ->(x, y) { x + y }

Example: EnforcedStyle: require_space

# bad
  a = ->(x, y) { x + y }

  # good
  a = -> (x, y) { x + y }

Do not use space inside array brackets.
Open

      selector = [ 'memories.id AS _key' ]
Severity: Minor
Found in app/models/memory.rb by rubocop

Checks that brackets used for array literals have or don't have surrounding space depending on configuration.

Example: EnforcedStyle: space

# The `space` style enforces that array literals have
# surrounding space.

# bad
array = [a, b, c, d]

# good
array = [ a, b, c, d ]

Example: EnforcedStyle: no_space

# The `no_space` style enforces that array literals have
# no surrounding space.

# bad
array = [ a, b, c, d ]

# good
array = [a, b, c, d]

Example: EnforcedStyle: compact

# The `compact` style normally requires a space inside
# array brackets, with the exception that successive left
# or right brackets are collapsed together in nested arrays.

# bad
array = [ a, [ b, c ] ]

# good
array = [ a, [ b, c ]]
Severity
Category
Status
Source
Language