Sign upLogin

BLSQ/orbf2

View on GitHub
Star
app/workers/invoice_simulation_worker.rb

Summary

Maintainability
A
50 mins
Test Coverage
A
98%

Method has too many lines. [12/10]
Open

  def uploaded_blob(name, serialized_json)
    gzipped = gzip(serialized_json)
    s3_client = ActiveStorage::Blob.service.client
    bucket = ActiveStorage::Blob.service.bucket
    blob = ActiveStorage::Blob.new
Severity: Minor
Found in app/workers/invoice_simulation_worker.rb by rubocop

This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

Method has too many lines. [11/10]
Open

    def invoicing_request
      return @request if @request

      request_options = {
        project:        project,
Severity: Minor
Found in app/workers/invoice_simulation_worker.rb by rubocop

This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

Method perform has 7 arguments (exceeds 4 allowed). Consider refactoring.
Open

  def perform(entity, period, project_id, with_details, engine_version, mocked_data, simulate_draft)
Severity: Major
Found in app/workers/invoice_simulation_worker.rb - About 50 mins to fix

    Avoid parameter lists longer than 5 parameters. [7/5]
    Open

      def perform(entity, period, project_id, with_details, engine_version, mocked_data, simulate_draft)
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

    This cop checks for methods with too many parameters. The maximum number of parameters is configurable. Keyword arguments can optionally be excluded from the total count.

    Line is too long. [118/100]
    Open

          @invoicing_entity ||= Invoicing::InvoiceEntity.new(project.project_anchor, invoicing_request, invoicing_options)
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

    Line is too long. [101/100]
    Open

        bucket.object(blob.key).put(body: io, content_type: "application/json", content_encoding: "gzip")
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

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

            force_project_id:       simulate_draft? ? project.id : nil,
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.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, one space before hash rockets and values)
- 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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

    Example: EnforcedHashRocketStyle: key (default)

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

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

    Example: EnforcedHashRocketStyle: separator

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

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

    Example: EnforcedHashRocketStyle: table

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

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

    Example: EnforcedColonStyle: key (default)

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

# good
{
  foo: bar,
  ba: baz
}

    Example: EnforcedColonStyle: separator

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
   ba: baz
}

    Example: EnforcedColonStyle: table

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
  ba:  baz
}

    Example: EnforcedLastArgumentHashStyle: always_inspect (default)

    # Inspect both implicit and explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
             bar: 2)

# good
do_something(
  foo: 1,
  bar: 2
)

# good
do_something({foo: 1,
              bar: 2})

# good
do_something({
  foo: 1,
  bar: 2
})

    Example: EnforcedLastArgumentHashStyle: always_ignore

    # Ignore both implicit and explicit hashes.

# good
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Example: EnforcedLastArgumentHashStyle: ignore_implicit

    # Ignore only implicit hashes.

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
  bar: 2)

    Example: EnforcedLastArgumentHashStyle: ignore_explicit

    # Ignore only explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Useless assignment to variable - indexed_project.
    Open

          indexed_project = Invoicing::IndexedProject.new(project, invoicing_entity.orbf_project)
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

    This cop checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

    assigned but unused variable - foo

    Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

    Example:

    # bad

def some_method
  some_var = 1
  do_something
end

    Example:

    # good

def some_method
  some_var = 1
  do_something(some_var)
end

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

            project:        project,
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.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, one space before hash rockets and values)
- 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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

    Example: EnforcedHashRocketStyle: key (default)

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

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

    Example: EnforcedHashRocketStyle: separator

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

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

    Example: EnforcedHashRocketStyle: table

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

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

    Example: EnforcedColonStyle: key (default)

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

# good
{
  foo: bar,
  ba: baz
}

    Example: EnforcedColonStyle: separator

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
   ba: baz
}

    Example: EnforcedColonStyle: table

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
  ba:  baz
}

    Example: EnforcedLastArgumentHashStyle: always_inspect (default)

    # Inspect both implicit and explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
             bar: 2)

# good
do_something(
  foo: 1,
  bar: 2
)

# good
do_something({foo: 1,
              bar: 2})

# good
do_something({
  foo: 1,
  bar: 2
})

    Example: EnforcedLastArgumentHashStyle: always_ignore

    # Ignore both implicit and explicit hashes.

# good
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Example: EnforcedLastArgumentHashStyle: ignore_implicit

    # Ignore only implicit hashes.

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
  bar: 2)

    Example: EnforcedLastArgumentHashStyle: ignore_explicit

    # Ignore only explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Useless assignment to variable - compressed.
    Open

        compressed = wio.string
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

    This cop checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

    assigned but unused variable - foo

    Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

    Example:

    # bad

def some_method
  some_var = 1
  do_something
end

    Example:

    # good

def some_method
  some_var = 1
  do_something(some_var)
end

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

        key_suffix:  ->(_entity, _period, project_id, _with_details, _engine_version, _mocked_data, _simulate_draft) { project_id }
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.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, one space before hash rockets and values)
- 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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

    Example: EnforcedHashRocketStyle: key (default)

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

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

    Example: EnforcedHashRocketStyle: separator

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

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

    Example: EnforcedHashRocketStyle: table

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

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

    Example: EnforcedColonStyle: key (default)

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

# good
{
  foo: bar,
  ba: baz
}

    Example: EnforcedColonStyle: separator

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
   ba: baz
}

    Example: EnforcedColonStyle: table

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
  ba:  baz
}

    Example: EnforcedLastArgumentHashStyle: always_inspect (default)

    # Inspect both implicit and explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
             bar: 2)

# good
do_something(
  foo: 1,
  bar: 2
)

# good
do_something({foo: 1,
              bar: 2})

# good
do_something({
  foo: 1,
  bar: 2
})

    Example: EnforcedLastArgumentHashStyle: always_ignore

    # Ignore both implicit and explicit hashes.

# good
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Example: EnforcedLastArgumentHashStyle: ignore_implicit

    # Ignore only implicit hashes.

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
  bar: 2)

    Example: EnforcedLastArgumentHashStyle: ignore_explicit

    # Ignore only explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

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

            publish_to_dhis2:       false,
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.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, one space before hash rockets and values)
- 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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

    Example: EnforcedHashRocketStyle: key (default)

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

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

    Example: EnforcedHashRocketStyle: separator

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

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

    Example: EnforcedHashRocketStyle: table

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

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

    Example: EnforcedColonStyle: key (default)

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

# good
{
  foo: bar,
  ba: baz
}

    Example: EnforcedColonStyle: separator

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
   ba: baz
}

    Example: EnforcedColonStyle: table

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
  ba:  baz
}

    Example: EnforcedLastArgumentHashStyle: always_inspect (default)

    # Inspect both implicit and explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
             bar: 2)

# good
do_something(
  foo: 1,
  bar: 2
)

# good
do_something({foo: 1,
              bar: 2})

# good
do_something({
  foo: 1,
  bar: 2
})

    Example: EnforcedLastArgumentHashStyle: always_ignore

    # Ignore both implicit and explicit hashes.

# good
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Example: EnforcedLastArgumentHashStyle: ignore_implicit

    # Ignore only implicit hashes.

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
  bar: 2)

    Example: EnforcedLastArgumentHashStyle: ignore_explicit

    # Ignore only explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

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

            year:           year,
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.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, one space before hash rockets and values)
- 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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

    Example: EnforcedHashRocketStyle: key (default)

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

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

    Example: EnforcedHashRocketStyle: separator

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

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

    Example: EnforcedHashRocketStyle: table

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

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

    Example: EnforcedColonStyle: key (default)

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

# good
{
  foo: bar,
  ba: baz
}

    Example: EnforcedColonStyle: separator

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
   ba: baz
}

    Example: EnforcedColonStyle: table

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
  ba:  baz
}

    Example: EnforcedLastArgumentHashStyle: always_inspect (default)

    # Inspect both implicit and explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
             bar: 2)

# good
do_something(
  foo: 1,
  bar: 2
)

# good
do_something({foo: 1,
              bar: 2})

# good
do_something({
  foo: 1,
  bar: 2
})

    Example: EnforcedLastArgumentHashStyle: always_ignore

    # Ignore both implicit and explicit hashes.

# good
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Example: EnforcedLastArgumentHashStyle: ignore_implicit

    # Ignore only implicit hashes.

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
  bar: 2)

    Example: EnforcedLastArgumentHashStyle: ignore_explicit

    # Ignore only explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Line is too long. [155/100]
    Open

          serialized_json = InvoiceSimulationWorker::Simulation.new(entity, period, project_id, engine_version, with_details, mocked_data, simulate_draft).call
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

    Line is too long. [106/100]
    Open

          @entity, @period, @project_id, @with_details, @engine_version, @mocked_data, @simulate_draft = *args
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

    Line is too long. [127/100]
    Open

        key_suffix:  ->(_entity, _period, project_id, _with_details, _engine_version, _mocked_data, _simulate_draft) { project_id }
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

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

            quarter:        quarter,
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.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, one space before hash rockets and values)
- 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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

    Example: EnforcedHashRocketStyle: key (default)

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

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

    Example: EnforcedHashRocketStyle: separator

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

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

    Example: EnforcedHashRocketStyle: table

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

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

    Example: EnforcedColonStyle: key (default)

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

# good
{
  foo: bar,
  ba: baz
}

    Example: EnforcedColonStyle: separator

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
   ba: baz
}

    Example: EnforcedColonStyle: table

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
  ba:  baz
}

    Example: EnforcedLastArgumentHashStyle: always_inspect (default)

    # Inspect both implicit and explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
             bar: 2)

# good
do_something(
  foo: 1,
  bar: 2
)

# good
do_something({foo: 1,
              bar: 2})

# good
do_something({
  foo: 1,
  bar: 2
})

    Example: EnforcedLastArgumentHashStyle: always_ignore

    # Ignore both implicit and explicit hashes.

# good
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Example: EnforcedLastArgumentHashStyle: ignore_implicit

    # Ignore only implicit hashes.

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
  bar: 2)

    Example: EnforcedLastArgumentHashStyle: ignore_explicit

    # Ignore only explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

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

            entity:         @entity,
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.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, one space before hash rockets and values)
- 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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

    Example: EnforcedHashRocketStyle: key (default)

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

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

    Example: EnforcedHashRocketStyle: separator

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

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

    Example: EnforcedHashRocketStyle: table

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

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

    Example: EnforcedColonStyle: key (default)

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

# good
{
  foo: bar,
  ba: baz
}

    Example: EnforcedColonStyle: separator

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
   ba: baz
}

    Example: EnforcedColonStyle: table

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
  ba:  baz
}

    Example: EnforcedLastArgumentHashStyle: always_inspect (default)

    # Inspect both implicit and explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
             bar: 2)

# good
do_something(
  foo: 1,
  bar: 2
)

# good
do_something({foo: 1,
              bar: 2})

# good
do_something({
  foo: 1,
  bar: 2
})

    Example: EnforcedLastArgumentHashStyle: always_ignore

    # Ignore both implicit and explicit hashes.

# good
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Example: EnforcedLastArgumentHashStyle: ignore_implicit

    # Ignore only implicit hashes.

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
  bar: 2)

    Example: EnforcedLastArgumentHashStyle: ignore_explicit

    # Ignore only explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Useless assignment to variable - s3_client.
    Open

        s3_client = ActiveStorage::Blob.service.client
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

    This cop checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

    assigned but unused variable - foo

    Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

    Example:

    # bad

def some_method
  some_var = 1
  do_something
end

    Example:

    # good

def some_method
  some_var = 1
  do_something(some_var)
end

    Avoid the use of double negation (!!).
    Open

          !!@simulate_draft
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

    This cop checks for uses of double negation (!!) to convert something to a boolean value. As this is both cryptic and usually redundant, it should be avoided.

    Example:

    # bad
!!something

# good
!something.nil?

    Please, note that when something is a boolean value !!something and !something.nil? are not the same thing. As you're unlikely to write code that can accept values of any type this is rarely a problem in practice.

    Prefer template tokens (like %{foo}) over unannotated tokens (like %s).
    Open

            name = format("%s.json", [project_id.to_s, entity, period].map(&:underscore).join("-"))
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

    Use a consistent style for named format string tokens.

    Note: unannotated style cop only works for strings which are passed as arguments to those methods: sprintf, format, %. The reason is that unannotated format is very similar to encoded URLs or Date/Time formatting strings.

    Example: EnforcedStyle: annotated (default)

    # bad
format('%{greeting}', greeting: 'Hello')
format('%s', 'Hello')

# good
format('%<greeting>s', greeting: 'Hello')</greeting>

    Example: EnforcedStyle: template

    # bad
format('%<greeting>s', greeting: 'Hello')
format('%s', 'Hello')

# good
format('%{greeting}', greeting: 'Hello')</greeting>

    Example: EnforcedStyle: unannotated

    # bad
format('%<greeting>s', greeting: 'Hello')
format('%{greeting}', 'Hello')

# good
format('%s', 'Hello')</greeting>

    Memoized variable @request does not match method name invoicing_request. Use @invoicing_request instead.
    Open

          @request ||= InvoicingRequest.new(request_options)
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.rb by rubocop

    This cop checks for memoized methods whose instance variable name does not match the method name.

    This cop can be configured with the EnforcedStyleForLeadingUnderscores directive. It can be configured to allow for memoized instance variables prefixed with an underscore. Prefixing ivars with an underscore is a convention that is used to implicitly indicate that an ivar should not be set or referencd outside of the memoization method.

    Example: EnforcedStyleForLeadingUnderscores: disallowed (default)

    # bad
# Method foo is memoized using an instance variable that is
# not `@foo`. This can cause confusion and bugs.
def foo
  @something ||= calculate_expensive_thing
end

# good
def _foo
  @foo ||= calculate_expensive_thing
end

# good
def foo
  @foo ||= calculate_expensive_thing
end

# good
def foo
  @foo ||= begin
    calculate_expensive_thing
  end
end

# good
def foo
  helper_variable = something_we_need_to_calculate_foo
  @foo ||= calculate_expensive_thing(helper_variable)
end

    Example: EnforcedStyleForLeadingUnderscores: required

    # bad
def foo
  @something ||= calculate_expensive_thing
end

# bad
def foo
  @foo ||= calculate_expensive_thing
end

# good
def foo
  @_foo ||= calculate_expensive_thing
end

# good
def _foo
  @_foo ||= calculate_expensive_thing
end

    Example: EnforcedStyleForLeadingUnderscores :optional

    # bad
def foo
  @something ||= calculate_expensive_thing
end

# good
def foo
  @foo ||= calculate_expensive_thing
end

# good
def foo
  @_foo ||= calculate_expensive_thing
end

# good
def _foo
  @_foo ||= calculate_expensive_thing
end

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

            with_details:   @with_details,
    Severity: Minor
    Found in app/workers/invoice_simulation_worker.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, one space before hash rockets and values)
- 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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

    Example: EnforcedHashRocketStyle: key (default)

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

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

    Example: EnforcedHashRocketStyle: separator

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

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

    Example: EnforcedHashRocketStyle: table

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

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

    Example: EnforcedColonStyle: key (default)

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

# good
{
  foo: bar,
  ba: baz
}

    Example: EnforcedColonStyle: separator

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
   ba: baz
}

    Example: EnforcedColonStyle: table

    # bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
  ba:  baz
}

    Example: EnforcedLastArgumentHashStyle: always_inspect (default)

    # Inspect both implicit and explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
             bar: 2)

# good
do_something(
  foo: 1,
  bar: 2
)

# good
do_something({foo: 1,
              bar: 2})

# good
do_something({
  foo: 1,
  bar: 2
})

    Example: EnforcedLastArgumentHashStyle: always_ignore

    # Ignore both implicit and explicit hashes.

# good
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    Example: EnforcedLastArgumentHashStyle: ignore_implicit

    # Ignore only implicit hashes.

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
  bar: 2)

    Example: EnforcedLastArgumentHashStyle: ignore_explicit

    # Ignore only explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

    There are no issues that match your filters.

    Category
    Status