Sign upLogin

ReadyResponder/ReadyResponder

View on GitHub
Star
spec/models/availability_spec.rb

Summary

Maintainability
A
2 hrs
Test Coverage

Block has too many lines. [251/25]
Open

RSpec.describe Availability, type: :model do
  let(:a_person) { build(:person) }

  before(:example) do
    Timecop.freeze
Severity: Minor
Found in spec/models/availability_spec.rb by rubocop

This cop checks if the length of a block exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable. The cop can be configured to ignore blocks passed to certain methods.

Block has too many lines. [51/25]
Open

  context 'partially_overlapping scope' do
    let (:start_time){ 1.day.from_now }
    let (:end_time){2.days.from_now }
    let(:people) { create_list(:person, 7) }
    let (:a1){create(:availability, person: people[0],
Severity: Minor
Found in spec/models/availability_spec.rb by rubocop

This cop checks if the length of a block exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable. The cop can be configured to ignore blocks passed to certain methods.

File availability_spec.rb has 254 lines of code (exceeds 250 allowed). Consider refactoring.
Open

require 'rails_helper'

RSpec.describe Availability, type: :model do
  let(:a_person) { build(:person) }
Severity: Minor
Found in spec/models/availability_spec.rb - About 2 hrs to fix

    Block has too many lines. [30/25]
    Open

      context 'overlapping scope' do
    it 'returns a chainable relation' do
      expect(described_class.overlapping([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    end
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks if the length of a block exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable. The cop can be configured to ignore blocks passed to certain methods.

    Block has too many lines. [28/25]
    Open

      context 'validation' do
    it { is_expected.to validate_presence_of(:person) }
    it { is_expected.to validate_presence_of(:status) }
    it { is_expected.to validate_presence_of(:start_time) }
    it { is_expected.to validate_presence_of(:end_time) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks if the length of a block exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable. The cop can be configured to ignore blocks passed to certain methods.

    Block has too many lines. [27/25]
    Open

      context 'contained_in scope' do
    it 'returns a chainable relation' do
      expect(described_class.contained_in([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    end
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks if the length of a block exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable. The cop can be configured to ignore blocks passed to certain methods.

    Block has too many lines. [27/25]
    Open

      context 'containing scope' do
    it 'returns a chainable relation' do
      expect(described_class.containing([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    end
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks if the length of a block exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable. The cop can be configured to ignore blocks passed to certain methods.

    Align the elements of a hash literal if they span more than one line.
    Open

              status: 'Cancelled', start_time: 1.hour.ago, end_time: 3.hours.from_now)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 3.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 65, 36 should be on its own line.
    Open

            availability.reload.status }.from('Available').to('Cancelled')
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Expression at 120, 87 should be on its own line.
    Open

                                       start_time: 1.hour.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Expression at 156, 83 should be on its own line.
    Open

                                       start_time: 3.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Extra blank line detected.
    Open
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cops checks for two or more consecutive blank lines.

    Example:

    # bad - It has two empty lines.
some_method
# one empty line
# two empty lines
some_method

# good
some_method
# one empty line
some_method

    Space inside parentheses detected.
    Open

                     start_time: start_time , end_time: end_time )}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for spaces inside ordinary round parentheses.

    Example:

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

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

    Align the elements of a hash literal if they span more than one line.
    Open

                               start_time: start_time, end_time: end_time)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 5.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                     start_time: start_time + 1.hour, end_time: end_time - 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 191, 81 should be on its own line.
    Open

                         start_time: end_time + 1.hour, end_time: end_time + 2.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Extra empty line detected at block body end.
    Open

    
    end
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cops checks if empty lines around the bodies of blocks match the configuration.

    Example: EnforcedStyle: empty_lines

    # good

foo do |bar|

  # ...

end

    Example: EnforcedStyle: noemptylines (default)

    # good

foo do |bar|
  # ...
end

    Align the elements of a hash literal if they span more than one line.
    Open

                          start_time: start_time, end_time: end_time)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Block body expression is on the same line as the block start.
    Open

          let!(:third_availability)  { create(:availability, person: people[2],
                                   start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              first_availability, second_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Expression at 116, 84 should be on its own line.
    Open

                                       start_time: 5.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              second_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Expression at 203, 88 should be on its own line.
    Open

                                       start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Block body expression is on the same line as the block start.
    Open

        let (:a6){create(:availability, person: people[5],
                     start_time: start_time - 2.hour, end_time: start_time - 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              third_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Space missing to the left of {.
    Open

        let (:a7){create(:availability, person: people[6],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have a space before the opening brace depending on configuration.

    Example:

    # bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 1.hour.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                         start_time: start_time - 2.hour, end_time: start_time - 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 181, 79 should be on its own line.
    Open

                     start_time: start_time + 1.hour, end_time: end_time + 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:first_availability)  { create(:availability, person: a_person,
                                   start_time: 5.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:second_availability) { create(:availability, person: a_person,
                                   start_time: 3.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Align the elements of a hash literal if they span more than one line.
    Open

                     start_time: start_time + 1.hour, end_time: end_time + 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Space missing to the left of {.
    Open

        let (:a1){create(:availability, person: people[0],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have a space before the opening brace depending on configuration.

    Example:

    # bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}

    Expression at 154, 84 should be on its own line.
    Open

                                       start_time: 5.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Space missing inside {.
    Open

        let (:end_time){2.days.from_now }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have surrounding space inside them on configuration. For blocks taking parameters, it checks that the left brace has or doesn't have trailing space depending on configuration.

    Example: EnforcedStyle: space (default)

    # The `space` style enforces that block braces have
# surrounding space.

# bad
some_array.each {puts e}

# good
some_array.each { puts e }

    Example: EnforcedStyle: no_space

    # The `no_space` style enforces that block braces don't
# have surrounding space.

# bad
some_array.each { puts e }

# good
some_array.each {puts e}

    Example: EnforcedStyleForEmptyBraces: no_space (default)

    # The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.

# bad
some_array.each {   }
some_array.each {  }
some_array.each { }

# good
some_array.each {}

    Example: EnforcedStyleForEmptyBraces: space

    # The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a spece in between when empty.

# bad
some_array.each {}

# good
some_array.each { }
some_array.each {  }
some_array.each {   }

    Example: SpaceBeforeBlockParameters: true (default)

    # The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each {|n| n * 2 }

# good
[1, 2, 3].each { |n| n * 2 }

    Example: SpaceBeforeBlockParameters: true

    # The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }

    Expression at 158, 87 should be on its own line.
    Open

                                       start_time: 1.hour.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:first_availability)  { create(:availability, person: people[0],
                                   start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              first_availability, third_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Space missing to the left of {.
    Open

        let (:a3){create(:availability, person: people[2],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have a space before the opening brace depending on configuration.

    Example:

    # bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}

    Space missing to the left of {.
    Open

        let (:a6){create(:availability, person: people[5],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have a space before the opening brace depending on configuration.

    Example:

    # bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}

    Space missing inside {.
    Open

        let (:a7){create(:availability, person: people[6],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have surrounding space inside them on configuration. For blocks taking parameters, it checks that the left brace has or doesn't have trailing space depending on configuration.

    Example: EnforcedStyle: space (default)

    # The `space` style enforces that block braces have
# surrounding space.

# bad
some_array.each {puts e}

# good
some_array.each { puts e }

    Example: EnforcedStyle: no_space

    # The `no_space` style enforces that block braces don't
# have surrounding space.

# bad
some_array.each { puts e }

# good
some_array.each {puts e}

    Example: EnforcedStyleForEmptyBraces: no_space (default)

    # The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.

# bad
some_array.each {   }
some_array.each {  }
some_array.each { }

# good
some_array.each {}

    Example: EnforcedStyleForEmptyBraces: space

    # The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a spece in between when empty.

# bad
some_array.each {}

# good
some_array.each { }
some_array.each {  }
some_array.each {   }

    Example: SpaceBeforeBlockParameters: true (default)

    # The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each {|n| n * 2 }

# good
[1, 2, 3].each { |n| n * 2 }

    Example: SpaceBeforeBlockParameters: true

    # The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }

    (...) interpreted as grouped expression.
    Open

        let (:end_time){2.days.from_now }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for space between the name of a called method and a left parenthesis.

    Example:

    # bad

puts (x + y)

    Example:

    # good

puts(x + y)

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 1.hour.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 187, 83 should be on its own line.
    Open

                         start_time: start_time - 1.hour, end_time: end_time + 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Block body expression is on the same line as the block start.
    Open

        let (:a5){create(:availability, person: people[4],
                     start_time: start_time - 1.hour, end_time: end_time + 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:third_availability)  { create(:availability, person: people[2],
                                   start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              first_availability, second_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Space missing after comma.
    Open

          expect(described_class.containing([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for comma (,) not followed by some kind of space.

    Example:

    # bad
[1,2]
{ foo:bar,}

# good
[1, 2]
{ foo:bar, }

    Space missing after comma.
    Open

          expect(described_class.contained_in([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for comma (,) not followed by some kind of space.

    Example:

    # bad
[1,2]
{ foo:bar,}

# good
[1, 2]
{ foo:bar, }

    Space found before comma.
    Open

                     start_time: start_time , end_time: end_time )}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for comma (,) preceded by space.

    Example:

    # bad
[1 , 2 , 3]
a(1 , 2)
each { |a , b| }

# good
[1, 2, 3]
a(1, 2)
each { |a, b| }

    Space missing inside {.
    Open

        let (:a5){create(:availability, person: people[4],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have surrounding space inside them on configuration. For blocks taking parameters, it checks that the left brace has or doesn't have trailing space depending on configuration.

    Example: EnforcedStyle: space (default)

    # The `space` style enforces that block braces have
# surrounding space.

# bad
some_array.each {puts e}

# good
some_array.each { puts e }

    Example: EnforcedStyle: no_space

    # The `no_space` style enforces that block braces don't
# have surrounding space.

# bad
some_array.each { puts e }

# good
some_array.each {puts e}

    Example: EnforcedStyleForEmptyBraces: no_space (default)

    # The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.

# bad
some_array.each {   }
some_array.each {  }
some_array.each { }

# good
some_array.each {}

    Example: EnforcedStyleForEmptyBraces: space

    # The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a spece in between when empty.

# bad
some_array.each {}

# good
some_array.each { }
some_array.each {  }
some_array.each {   }

    Example: SpaceBeforeBlockParameters: true (default)

    # The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each {|n| n * 2 }

# good
[1, 2, 3].each { |n| n * 2 }

    Example: SpaceBeforeBlockParameters: true

    # The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }

    (...) interpreted as grouped expression.
    Open

        let (:start_time){ 1.day.from_now }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for space between the name of a called method and a left parenthesis.

    Example:

    # bad

puts (x + y)

    Example:

    # good

puts(x + y)

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 247, 84 should be on its own line.
    Open

                                       start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Block body expression is on the same line as the block start.
    Open

        let (:a4){create(:availability, person: people[3],
                 start_time: start_time , end_time: end_time )}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:first_availability)  { create(:availability, person: people[0],
                                   start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Space missing after comma.
    Open

          expect(described_class.partially_overlapping([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for comma (,) not followed by some kind of space.

    Example:

    # bad
[1,2]
{ foo:bar,}

# good
[1, 2]
{ foo:bar, }

    Space missing inside {.
    Open

        let (:a2){create(:availability, person: people[1],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have surrounding space inside them on configuration. For blocks taking parameters, it checks that the left brace has or doesn't have trailing space depending on configuration.

    Example: EnforcedStyle: space (default)

    # The `space` style enforces that block braces have
# surrounding space.

# bad
some_array.each {puts e}

# good
some_array.each { puts e }

    Example: EnforcedStyle: no_space

    # The `no_space` style enforces that block braces don't
# have surrounding space.

# bad
some_array.each { puts e }

# good
some_array.each {puts e}

    Example: EnforcedStyleForEmptyBraces: no_space (default)

    # The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.

# bad
some_array.each {   }
some_array.each {  }
some_array.each { }

# good
some_array.each {}

    Example: EnforcedStyleForEmptyBraces: space

    # The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a spece in between when empty.

# bad
some_array.each {}

# good
some_array.each { }
some_array.each {  }
some_array.each {   }

    Example: SpaceBeforeBlockParameters: true (default)

    # The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each {|n| n * 2 }

# good
[1, 2, 3].each { |n| n * 2 }

    Example: SpaceBeforeBlockParameters: true

    # The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }

    Space missing inside }.
    Open

          let(:results){Availability.partially_overlapping((start_time..end_time))}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have surrounding space inside them on configuration. For blocks taking parameters, it checks that the left brace has or doesn't have trailing space depending on configuration.

    Example: EnforcedStyle: space (default)

    # The `space` style enforces that block braces have
# surrounding space.

# bad
some_array.each {puts e}

# good
some_array.each { puts e }

    Example: EnforcedStyle: no_space

    # The `no_space` style enforces that block braces don't
# have surrounding space.

# bad
some_array.each { puts e }

# good
some_array.each {puts e}

    Example: EnforcedStyleForEmptyBraces: no_space (default)

    # The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.

# bad
some_array.each {   }
some_array.each {  }
some_array.each { }

# good
some_array.each {}

    Example: EnforcedStyleForEmptyBraces: space

    # The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a spece in between when empty.

# bad
some_array.each {}

# good
some_array.each { }
some_array.each {  }
some_array.each {   }

    Example: SpaceBeforeBlockParameters: true (default)

    # The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each {|n| n * 2 }

# good
[1, 2, 3].each { |n| n * 2 }

    Example: SpaceBeforeBlockParameters: true

    # The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }

    (...) interpreted as grouped expression.
    Open

        let (:a6){create(:availability, person: people[5],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for space between the name of a called method and a left parenthesis.

    Example:

    # bad

puts (x + y)

    Example:

    # good

puts(x + y)

    Line is too long. [106/80]
    Open

          availability = build(:availability, person: a_person, start_time: Time.now, end_time: 2.minutes.ago)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Expression at 183, 79 should be on its own line.
    Open

                     start_time: start_time + 1.hour, end_time: end_time - 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Expression at 189, 85 should be on its own line.
    Open

                         start_time: start_time - 2.hour, end_time: start_time - 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Expression at 199, 84 should be on its own line.
    Open

                                       start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Block body expression is on the same line as the block start.
    Open

        let (:a1){create(:availability, person: people[0],
                 start_time: start_time - 1.hour, end_time: end_time - 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:second_availability) { create(:availability, person: people[1],
                                   start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              second_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Space missing after comma.
    Open

          expect(described_class.not_overlapping([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for comma (,) not followed by some kind of space.

    Example:

    # bad
[1,2]
{ foo:bar,}

# good
[1, 2]
{ foo:bar, }

    Space missing to the left of {.
    Open

        let (:a2){create(:availability, person: people[1],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have a space before the opening brace depending on configuration.

    Example:

    # bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}

    (...) interpreted as grouped expression.
    Open

        let (:a2){create(:availability, person: people[1],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for space between the name of a called method and a left parenthesis.

    Example:

    # bad

puts (x + y)

    Example:

    # good

puts(x + y)

    (...) interpreted as grouped expression.
    Open

        let (:a3){create(:availability, person: people[2],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for space between the name of a called method and a left parenthesis.

    Example:

    # bad

puts (x + y)

    Example:

    # good

puts(x + y)

    Align the elements of a hash literal if they span more than one line.
    Open

                                start_time: start_time, end_time: end_time + 2.minutes)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 179, 79 should be on its own line.
    Open

                     start_time: start_time - 1.hour, end_time: end_time - 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:second_availability) { create(:availability, person: a_person,
                                   start_time: 3.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Space missing after comma.
    Open

          expect(described_class.overlapping([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for comma (,) not followed by some kind of space.

    Example:

    # bad
[1,2]
{ foo:bar,}

# good
[1, 2]
{ foo:bar, }

    Space missing inside {.
    Open

        let (:a6){create(:availability, person: people[5],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have surrounding space inside them on configuration. For blocks taking parameters, it checks that the left brace has or doesn't have trailing space depending on configuration.

    Example: EnforcedStyle: space (default)

    # The `space` style enforces that block braces have
# surrounding space.

# bad
some_array.each {puts e}

# good
some_array.each { puts e }

    Example: EnforcedStyle: no_space

    # The `no_space` style enforces that block braces don't
# have surrounding space.

# bad
some_array.each { puts e }

# good
some_array.each {puts e}

    Example: EnforcedStyleForEmptyBraces: no_space (default)

    # The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.

# bad
some_array.each {   }
some_array.each {  }
some_array.each { }

# good
some_array.each {}

    Example: EnforcedStyleForEmptyBraces: space

    # The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a spece in between when empty.

# bad
some_array.each {}

# good
some_array.each { }
some_array.each {  }
some_array.each {   }

    Example: SpaceBeforeBlockParameters: true (default)

    # The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each {|n| n * 2 }

# good
[1, 2, 3].each { |n| n * 2 }

    Example: SpaceBeforeBlockParameters: true

    # The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }

    (...) interpreted as grouped expression.
    Open

        let (:a5){create(:availability, person: people[4],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for space between the name of a called method and a left parenthesis.

    Example:

    # bad

puts (x + y)

    Example:

    # good

puts(x + y)

    Align the elements of a hash literal if they span more than one line.
    Open

                start_time: 1.day.ago, end_time: 1.day.from_now)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    (...) interpreted as grouped expression.
    Open

        let (:a7){create(:availability, person: people[6],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for space between the name of a called method and a left parenthesis.

    Example:

    # bad

puts (x + y)

    Example:

    # good

puts(x + y)

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 5.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 34, 62 should be on its own line.
    Open

            start_time: 2.hours.ago, end_time: 2.hours.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Expression at 201, 83 should be on its own line.
    Open

                                       start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Extra blank line detected.
    Open

    
      it 'returns the availabilities that contain a part of the given date_range' do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cops checks for two or more consecutive blank lines.

    Example:

    # bad - It has two empty lines.
some_method
# one empty line
# two empty lines
some_method

# good
some_method
# one empty line
some_method

    Block body expression is on the same line as the block start.
    Open

          let!(:first_availability)  { create(:availability, person: a_person,
                                   start_time: 5.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:second_availability) { create(:availability, person: people[1],
                                   start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              third_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Space missing to the left of {.
    Open

        let (:start_time){ 1.day.from_now }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have a space before the opening brace depending on configuration.

    Example:

    # bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}

    Space missing to the left of {.
    Open

        let (:a4){create(:availability, person: people[3],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have a space before the opening brace depending on configuration.

    Example:

    # bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}

    Space missing inside {.
    Open

        let (:a1){create(:availability, person: people[0],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have surrounding space inside them on configuration. For blocks taking parameters, it checks that the left brace has or doesn't have trailing space depending on configuration.

    Example: EnforcedStyle: space (default)

    # The `space` style enforces that block braces have
# surrounding space.

# bad
some_array.each {puts e}

# good
some_array.each { puts e }

    Example: EnforcedStyle: no_space

    # The `no_space` style enforces that block braces don't
# have surrounding space.

# bad
some_array.each { puts e }

# good
some_array.each {puts e}

    Example: EnforcedStyleForEmptyBraces: no_space (default)

    # The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.

# bad
some_array.each {   }
some_array.each {  }
some_array.each { }

# good
some_array.each {}

    Example: EnforcedStyleForEmptyBraces: space

    # The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a spece in between when empty.

# bad
some_array.each {}

# good
some_array.each { }
some_array.each {  }
some_array.each {   }

    Example: SpaceBeforeBlockParameters: true (default)

    # The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each {|n| n * 2 }

# good
[1, 2, 3].each { |n| n * 2 }

    Example: SpaceBeforeBlockParameters: true

    # The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }

    Align the elements of a hash literal if they span more than one line.
    Open

              start_time: 1.hour.ago, end_time: 3.hours.from_now)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                     start_time: start_time , end_time: end_time )}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 281, 84 should be on its own line.
    Open

                                       start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:third_availability)  { create(:availability, person: a_person,
                                   start_time: 1.hour.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Align the elements of a hash literal if they span more than one line.
    Open

            start_time: 2.hours.ago, end_time: 2.hours.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                         start_time: start_time - 1.hour, end_time: end_time + 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Block body expression is on the same line as the block start.
    Open

        let (:a7){create(:availability, person: people[6],
                     start_time: end_time + 1.hour, end_time: end_time + 2.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:third_availability)  { create(:availability, person: people[2],
                                   start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              second_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 3.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 283, 83 should be on its own line.
    Open

                                       start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Extra blank line detected.
    Open
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cops checks for two or more consecutive blank lines.

    Example:

    # bad - It has two empty lines.
some_method
# one empty line
# two empty lines
some_method

# good
some_method
# one empty line
some_method

    Block body expression is on the same line as the block start.
    Open

          let!(:third_availability)  { create(:availability, person: a_person,
                                   start_time: 1.hour.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Block body expression is on the same line as the block start.
    Open

        let (:a3){create(:availability, person: people[2],
                 start_time: start_time + 1.hour, end_time: end_time - 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:first_availability)  { create(:availability, person: people[0],
                                   start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              first_availability, third_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              first_availability, second_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Space missing inside {.
    Open

          let(:results){Availability.partially_overlapping((start_time..end_time))}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have surrounding space inside them on configuration. For blocks taking parameters, it checks that the left brace has or doesn't have trailing space depending on configuration.

    Example: EnforcedStyle: space (default)

    # The `space` style enforces that block braces have
# surrounding space.

# bad
some_array.each {puts e}

# good
some_array.each { puts e }

    Example: EnforcedStyle: no_space

    # The `no_space` style enforces that block braces don't
# have surrounding space.

# bad
some_array.each { puts e }

# good
some_array.each {puts e}

    Example: EnforcedStyleForEmptyBraces: no_space (default)

    # The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.

# bad
some_array.each {   }
some_array.each {  }
some_array.each { }

# good
some_array.each {}

    Example: EnforcedStyleForEmptyBraces: space

    # The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a spece in between when empty.

# bad
some_array.each {}

# good
some_array.each { }
some_array.each {  }
some_array.each {   }

    Example: SpaceBeforeBlockParameters: true (default)

    # The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each {|n| n * 2 }

# good
[1, 2, 3].each { |n| n * 2 }

    Example: SpaceBeforeBlockParameters: true

    # The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }

    (...) interpreted as grouped expression.
    Open

        let (:a1){create(:availability, person: people[0],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for space between the name of a called method and a left parenthesis.

    Example:

    # bad

puts (x + y)

    Example:

    # good

puts(x + y)

    (...) interpreted as grouped expression.
    Open

        let (:a4){create(:availability, person: people[3],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks for space between the name of a called method and a left parenthesis.

    Example:

    # bad

puts (x + y)

    Example:

    # good

puts(x + y)

    Align the elements of a hash literal if they span more than one line.
    Open

              start_time: 2.hours.ago, end_time: 3.hours.from_now)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                                       start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 185, 63 should be on its own line.
    Open

                     start_time: start_time , end_time: end_time )}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Block body expression is on the same line as the block start.
    Open

        let (:a2){create(:availability, person: people[1],
                 start_time: start_time + 1.hour, end_time: end_time + 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Space missing to the left of {.
    Open

        let (:a5){create(:availability, person: people[4],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have a space before the opening brace depending on configuration.

    Example:

    # bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}

    Align the elements of a hash literal if they span more than one line.
    Open

                     start_time: start_time - 1.hour, end_time: end_time - 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 249, 83 should be on its own line.
    Open

                                       start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Expression at 285, 88 should be on its own line.
    Open

                                       start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Block body expression is on the same line as the block start.
    Open

          let!(:second_availability) { create(:availability, person: people[1],
                                   start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              first_availability, third_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Space missing to the left of {.
    Open

          let(:results){Availability.partially_overlapping((start_time..end_time))}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have a space before the opening brace depending on configuration.

    Example:

    # bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}

    Space missing inside {.
    Open

        let (:a4){create(:availability, person: people[3],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have surrounding space inside them on configuration. For blocks taking parameters, it checks that the left brace has or doesn't have trailing space depending on configuration.

    Example: EnforcedStyle: space (default)

    # The `space` style enforces that block braces have
# surrounding space.

# bad
some_array.each {puts e}

# good
some_array.each { puts e }

    Example: EnforcedStyle: no_space

    # The `no_space` style enforces that block braces don't
# have surrounding space.

# bad
some_array.each { puts e }

# good
some_array.each {puts e}

    Example: EnforcedStyleForEmptyBraces: no_space (default)

    # The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.

# bad
some_array.each {   }
some_array.each {  }
some_array.each { }

# good
some_array.each {}

    Example: EnforcedStyleForEmptyBraces: space

    # The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a spece in between when empty.

# bad
some_array.each {}

# good
some_array.each { }
some_array.each {  }
some_array.each {   }

    Example: SpaceBeforeBlockParameters: true (default)

    # The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each {|n| n * 2 }

# good
[1, 2, 3].each { |n| n * 2 }

    Example: SpaceBeforeBlockParameters: true

    # The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }

    Align the elements of a hash literal if they span more than one line.
    Open

                start_time: 1.day.ago, end_time: 1.day.from_now, status: 'Available')
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                         start_time: start_time, end_time: end_time)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Align the elements of a hash literal if they span more than one line.
    Open

                         start_time: end_time + 1.hour, end_time: end_time + 2.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

    - key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

    The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

    - always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

    Example:

    # EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)

# good
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}

# bad
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Example:

    # EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator

#good
{
  foo: bar,
   ba: baz
}
{
  :foo => bar,
   :ba => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

    Example:

    # EnforcedHashRocketStyle: table
# EnforcedColonStyle: table

#good
{
  foo: bar,
  ba:  baz
}
{
  :foo => bar,
  :ba  => baz
}

#bad
{
  foo: bar,
  ba: baz
}
{
  :foo => bar,
   :ba => baz
}

    Expression at 118, 83 should be on its own line.
    Open

                                       start_time: 3.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Expression at 251, 88 should be on its own line.
    Open

                                       start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the end statement of a do..end block is on its own line.

    Example:

    # bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

    Block body expression is on the same line as the block start.
    Open

          let(:availability) { build(:availability, person: a_person,
        start_time: 2.hours.ago, end_time: 2.hours.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks whether the multiline do end blocks have a newline after the start of the block. Additionally, it checks whether the block arguments, if any, are on the same line as the start of the block.

    Example:

    # bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

    Closing method call brace must be on the line after the last argument when opening brace is on a separate line from the first argument.
    Open

              second_availability)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop checks that the closing brace in a method call is either on the same line as the last method argument, or a new line.

    When using the symmetrical (default) style:

    If a method call's opening brace is on the same line as the first argument of the call, then the closing brace should be on the same line as the last argument of the call.

    If an method call's opening brace is on the line above the first argument of the call, then the closing brace should be on the line below the last argument of the call.

    When using the new_line style:

    The closing brace of a multi-line method call must be on the line after the last argument of the call.

    When using the same_line style:

    The closing brace of a multi-line method call must be on the same line as the last argument of the call.

    Example:

    # symmetrical: bad
  # new_line: good
  # same_line: bad
  foo(a,
    b
  )

  # symmetrical: bad
  # new_line: bad
  # same_line: good
  foo(
    a,
    b)

  # symmetrical: good
  # new_line: bad
  # same_line: good
  foo(a,
    b)

  # symmetrical: good
  # new_line: good
  # same_line: bad
  foo(
    a,
    b
  )

    Space missing to the left of {.
    Open

        let (:end_time){2.days.from_now }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have a space before the opening brace depending on configuration.

    Example:

    # bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}

    Space missing inside {.
    Open

        let (:a3){create(:availability, person: people[2],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Checks that block braces have or don't have surrounding space inside them on configuration. For blocks taking parameters, it checks that the left brace has or doesn't have trailing space depending on configuration.

    Example: EnforcedStyle: space (default)

    # The `space` style enforces that block braces have
# surrounding space.

# bad
some_array.each {puts e}

# good
some_array.each { puts e }

    Example: EnforcedStyle: no_space

    # The `no_space` style enforces that block braces don't
# have surrounding space.

# bad
some_array.each { puts e }

# good
some_array.each {puts e}

    Example: EnforcedStyleForEmptyBraces: no_space (default)

    # The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.

# bad
some_array.each {   }
some_array.each {  }
some_array.each { }

# good
some_array.each {}

    Example: EnforcedStyleForEmptyBraces: space

    # The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a spece in between when empty.

# bad
some_array.each {}

# good
some_array.each { }
some_array.each {  }
some_array.each {   }

    Example: SpaceBeforeBlockParameters: true (default)

    # The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each {|n| n * 2 }

# good
[1, 2, 3].each { |n| n * 2 }

    Example: SpaceBeforeBlockParameters: true

    # The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }

    Line is too long. [98/80]
    Open

          expect(described_class.partially_overlapping([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [83/80]
    Open

          it "should include partial responses that are > start time and > end time" do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Avoid using {...} for multi-line blocks.
    Open

          let!(:second_availability) { create(:availability, person: people[1],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

          let!(:third_availability)  { create(:availability, person: a_person,
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

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

      describe "creation" do
    Severity: Minor
    Found in spec/models/availability_spec.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"

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

        it "has a valid factory" do
    Severity: Minor
    Found in spec/models/availability_spec.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"

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

        it "requires end_time to be after start_time" do # chronology
    Severity: Minor
    Found in spec/models/availability_spec.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"

    Line is too long. [88/80]
    Open

          expect(described_class.overlapping([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [92/80]
    Open

          expect(described_class.not_overlapping([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [87/80]
    Open

                                       start_time: 1.hour.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [85/80]
    Open

            expect(described_class.partially_overlapping(date_range)).to contain_exactly(
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [88/80]
    Open

          it 'does not return availabilities that are contiguous to the given date_range' do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

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

          it "should include partial responses that are > start time and > end time" do
    Severity: Minor
    Found in spec/models/availability_spec.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"

    Line is too long. [84/80]
    Open

        it 'returns false for full availabilities which extend past event boundaries' do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Avoid using {...} for multi-line blocks.
    Open

          let!(:first_availability)  { create(:availability, person: people[0],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Missing magic comment # frozen_string_literal: true.
    Open

    require 'rails_helper'
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    This cop is designed to help upgrade to Ruby 3.0. It will add the comment # frozen_string_literal: true to the top of files to enable frozen string literals. Frozen string literals may be default in Ruby 3.0. The comment will be added below a shebang and encoding comment. The frozen string literal comment is only valid in Ruby 2.3+.

    Example: EnforcedStyle: when_needed (default)

    # The `when_needed` style will add the frozen string literal comment
# to files only when the `TargetRubyVersion` is set to 2.3+.
# bad
module Foo
  # ...
end

# good
# frozen_string_literal: true

module Foo
  # ...
end

    Example: EnforcedStyle: always

    # The `always` style will always add the frozen string literal comment
# to a file, regardless of the Ruby version or if `freeze` or `<<` are
# called on a string literal.
# bad
module Bar
  # ...
end

# good
# frozen_string_literal: true

module Bar
  # ...
end

    Example: EnforcedStyle: never

    # The `never` will enforce that the frozen string literal comment does
# not exist in a file.
# bad
# frozen_string_literal: true

module Baz
  # ...
end

# good
module Baz
  # ...
end

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

          it "should include partial responses that are < start_time and < end time" do
    Severity: Minor
    Found in spec/models/availability_spec.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"

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

          it "should include partial responses that are > start time and < end time" do
    Severity: Minor
    Found in spec/models/availability_spec.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"

    Line is too long. [83/80]
    Open

                                start_time: start_time, end_time: end_time + 2.minutes)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Avoid using {...} for multi-line blocks.
    Open

          let!(:first_availability)  { create(:availability, person: people[0],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

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

          event = create(:event, status: "Scheduled",
    Severity: Minor
    Found in spec/models/availability_spec.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"

    Line is too long. [82/80]
    Open

              status: 'Cancelled', start_time: 1.hour.ago, end_time: 3.hours.from_now)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [84/80]
    Open

                                       start_time: 5.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [83/80]
    Open

                                       start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [88/80]
    Open

                                       start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Avoid using {...} for multi-line blocks.
    Open

          let!(:second_availability) { create(:availability, person: a_person,
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

        let (:a2){create(:availability, person: people[1],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

          let!(:third_availability)  { create(:availability, person: people[2],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

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

          event = create(:event, status: "Scheduled",
    Severity: Minor
    Found in spec/models/availability_spec.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"

    Line is too long. [81/80]
    Open

                start_time: 1.day.ago, end_time: 1.day.from_now, status: 'Available')
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [100/80]
    Open

          it 'returns the availabilities whose duration is partially covered by the given date_range' do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [83/80]
    Open

          it "should include partial responses that are > start time and < end time" do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

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

        context "confirmation of date comparison" do
    Severity: Minor
    Found in spec/models/availability_spec.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"

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

          it "should not include responses that are entirely before start_time" do
    Severity: Minor
    Found in spec/models/availability_spec.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"

    Line is too long. [83/80]
    Open

                         start_time: start_time - 1.hour, end_time: end_time + 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [81/80]
    Open

                         start_time: end_time + 1.hour, end_time: end_time + 2.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [83/80]
    Open

                                       start_time: 3.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [81/80]
    Open

            date_range = second_availability.start_time..second_availability.end_time
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Avoid using {...} for multi-line blocks.
    Open

          let!(:first_availability)  { create(:availability, person: people[0],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

        let (:a1){create(:availability, person: people[0],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

          let!(:third_availability)  { create(:availability, person: people[2],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Line is too long. [88/80]
    Open

          it 'does not return availabilities that are contiguous to the given date_range' do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [84/80]
    Open

                                       start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [84/80]
    Open

          it 'returns the availabilities that contain a part of the given date_range' do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [81/80]
    Open

            date_range = second_availability.start_time..second_availability.end_time
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [89/80]
    Open

          expect(described_class.contained_in([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Avoid using {...} for multi-line blocks.
    Open

          let!(:first_availability)  { create(:availability, person: a_person,
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

        let (:a4){create(:availability, person: people[3],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

        let (:a7){create(:availability, person: people[6],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

          let!(:second_availability) { create(:availability, person: people[1],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Line is too long. [84/80]
    Open

                                       start_time: 5.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [93/80]
    Open

          it 'returns the availabilities whose duration does not overlap the given date_range' do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [87/80]
    Open

          expect(described_class.containing([0,1])).to be_a_kind_of(ActiveRecord::Relation)
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Avoid using {...} for multi-line blocks.
    Open

          let(:availability) { build(:availability, person: a_person,
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

          let!(:second_availability) { create(:availability, person: people[1],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Line is too long. [84/80]
    Open

          it 'returns an availability that begins at the end of the given date_range' do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [88/80]
    Open

                                       start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [83/80]
    Open

                                       start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

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

          it "should not include responses that are entirely after end_time" do
    Severity: Minor
    Found in spec/models/availability_spec.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"

    Line is too long. [94/80]
    Open

          it 'returns none of them if the given range does not cover any of the availabilities' do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [83/80]
    Open

                                       start_time: 3.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [84/80]
    Open

                                       start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [88/80]
    Open

                                       start_time: 2.hours.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Avoid using {...} for multi-line blocks.
    Open

          let!(:third_availability)  { create(:availability, person: a_person,
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

          let!(:first_availability)  { create(:availability, person: a_person,
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

        let (:a5){create(:availability, person: people[4],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Line is too long. [83/80]
    Open

          it "should include partial responses that are < start_time and < end time" do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [83/80]
    Open

                                       start_time: 4.hours.ago, end_time: 1.hour.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [88/80]
    Open

          it 'does not return availabilities that are contiguous to the given date_range' do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [84/80]
    Open

                                       start_time: 6.hours.ago, end_time: 3.hours.ago) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [81/80]
    Open

            date_range = second_availability.start_time..second_availability.end_time
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [87/80]
    Open

        let(:availability) { create(:availability, person: a_person, status: 'Available') }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [87/80]
    Open

                                       start_time: 1.hour.ago, end_time: 1.hour.from_now) }
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Line is too long. [85/80]
    Open

                         start_time: start_time - 2.hour, end_time: start_time - 1.hour)}
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Avoid using {...} for multi-line blocks.
    Open

          let!(:second_availability) { create(:availability, person: a_person,
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Line is too long. [85/80]
    Open

          it 'returns the availabilities that fully contained by the given date_range' do
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Avoid using {...} for multi-line blocks.
    Open

        let (:a3){create(:availability, person: people[2],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

        let (:a6){create(:availability, person: people[5],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    Avoid using {...} for multi-line blocks.
    Open

          let!(:third_availability)  { create(:availability, person: people[2],
    Severity: Minor
    Found in spec/models/availability_spec.rb by rubocop

    Check for uses of braces or do/end around single line or multi-line blocks.

    Example: EnforcedStyle: linecountbased (default)

    # bad - single line block
items.each do |item| item / 5 end

# good - single line block
items.each { |item| item / 5 }

# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}

# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

    Example: EnforcedStyle: semantic

    # Prefer `do...end` over `{...}` for procedural blocks.

# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)

# return value is not used out of scope
# good
map do |x|
  x
end

# Prefer `{...}` over `do...end` for functional blocks.

# return value is not used out of scope
# bad
each { |x|
  x
}

# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

    Example: EnforcedStyle: bracesforchaining

    # bad
words.each do |word|
  word.flip.flop
end.join("-")

# good
words.each { |word|
  word.flip.flop
}.join("-")

    There are no issues that match your filters.

    Category
    Status