gitshowcase/gitshowcase

View on GitHub
app/services/import/city_service.rb

Summary

Maintainability
A
0 mins
Test Coverage

Assignment Branch Condition size for import is too high. [35.71/15]
Open

  def import
    countries = Hash[Country.select(:id, :abbreviation).map { |country| [country.abbreviation, country.id] }]
    timezones = Hash[Timezone.select(:id, :slug).map { |timezone| [timezone.slug, timezone.id] }]

    states_result = State.select(:id, :abbreviation, 'countries.abbreviation as country_abbreviation').joins(:country).map do |state|
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

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

  def import
    countries = Hash[Country.select(:id, :abbreviation).map { |country| [country.abbreviation, country.id] }]
    timezones = Hash[Timezone.select(:id, :slug).map { |timezone| [timezone.slug, timezone.id] }]

    states_result = State.select(:id, :abbreviation, 'countries.abbreviation as country_abbreviation').joins(:country).map do |state|
Severity: Minor
Found in app/services/import/city_service.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.

Line is too long. [105/80]
Open

        'states.abbreviation as state', 'countries.abbreviation as country', 'timezones.slug as timezone'
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

Line is too long. [92/80]
Open

          state_id: record['state'].present? ? states["#{country}:#{record['state']}"] : nil
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

Line is too long. [109/80]
Open

    City.import cities, on_duplicate_key_update: {conflict_target: [:key], columns: columns}, validate: false
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

Use %i or %I for an array of symbols.
Open

    columns = [:name, :full_name, :latitude, :longitude, :population, :capital, :country_id, :timezone_id, :state_id]
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

This cop can check for array literals made up of symbols that are not using the %i() syntax.

Alternatively, it checks for symbol arrays using the %i() syntax on projects which do not want to use that syntax.

Configuration option: MinSize If set, arrays with fewer elements than this value will not trigger the cop. For example, a MinSize of3` will not enforce a style on an array of 2 or fewer elements.

Example: EnforcedStyle: percent (default)

# good
%i[foo bar baz]

# bad
[:foo, :bar, :baz]

Example: EnforcedStyle: brackets

# good
[:foo, :bar, :baz]

# bad
%i[foo bar baz]

Align the elements of an array literal if they span more than one line.
Open

        'states.abbreviation as state', 'countries.abbreviation as country', 'timezones.slug as timezone'
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

Here we check if the elements of a multi-line array literal are aligned.

Example:

# bad
a = [1, 2, 3,
  4, 5, 6]
array = ['run',
     'forrest',
     'run']

# good
a = [1, 2, 3,
     4, 5, 6]
a = ['run',
     'forrest',
     'run']

Use 2 spaces for indentation in a hash, relative to the start of the line where the left curly brace is.
Open

          key: record['key'],
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

This cops checks the indentation of the first key in a hash literal where the opening brace and the first key are on separate lines. The other keys' indentations are handled by the AlignHash cop.

By default, Hash literals that are arguments in a method call with parentheses, and where the opening curly brace of the hash is on the same line as the opening parenthesis of the method call, shall have their first key indented one step (two spaces) more than the position inside the opening parenthesis.

Other hash literals shall have their first key indented one step more than the start of the line where the opening curly brace is.

This default style is called 'specialinsideparentheses'. Alternative styles are 'consistent' and 'align_braces'. Here are examples:

Example: EnforcedStyle: specialinsideparentheses (default)

# The `special_inside_parentheses` style enforces that the first key
# in a hash literal where the opening brace and the first key are on
# separate lines is indented one step (two spaces) more than the
# position inside the opening parentheses.

# bad
hash = {
  key: :value
}
and_in_a_method_call({
  no: :difference
                     })

# good
special_inside_parentheses
hash = {
  key: :value
}
but_in_a_method_call({
                       its_like: :this
                     })

Example: EnforcedStyle: consistent

# The `consistent` style enforces that the first key in a hash
# literal where the opening brace and the first key are on
# seprate lines is indented the same as a hash literal which is not
# defined inside a method call.

# bad
hash = {
  key: :value
}
but_in_a_method_call({
                       its_like: :this
                      })

# good
hash = {
  key: :value
}
and_in_a_method_call({
  no: :difference
})

Example: EnforcedStyle: align_braces

# The `align_brackets` style enforces that the opening and closing
# braces are indented to the same position.

# bad
and_now_for_something = {
                          completely: :different
}

# good
and_now_for_something = {
                          completely: :different
                        }

Line is too long. [117/80]
Open

    columns = [:name, :full_name, :latitude, :longitude, :population, :capital, :country_id, :timezone_id, :state_id]
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

Line is too long. [83/80]
Open

    fields = :name, :key, :full_name, :latitude, :longitude, :population, :capital,
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

protected (on line 40) does not make singleton methods protected. Use protected inside a class << self block instead.
Open

  def self.filename
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

This cop checks for private or protected access modifiers which are applied to a singleton method. These access modifiers do not make singleton methods private/protected. private_class_method can be used for that.

Example:

# bad

class C
  private

  def self.method
    puts 'hi'
  end
end

Example:

# good

class C
  def self.method
    puts 'hi'
  end

  private_class_method :method
end

Example:

# good

class C
  class << self
    private

    def method
      puts 'hi'
    end
  end
end

Line is too long. [97/80]
Open

    timezones = Hash[Timezone.select(:id, :slug).map { |timezone| [timezone.slug, timezone.id] }]
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

Space inside { missing.
Open

    City.import cities, on_duplicate_key_update: {conflict_target: [:key], columns: columns}, validate: false
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

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

Example: EnforcedStyle: space

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

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

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

Example: EnforcedStyle: no_space

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

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

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

Example: EnforcedStyle: compact

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

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

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

Use nested module/class definitions instead of compact style.
Open

class Import::CityService < ImportService
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

This cop checks the style of children definitions at classes and modules. Basically there are two different styles:

Example: EnforcedStyle: nested (default)

# good
# have each child on its own line
class Foo
  class Bar
  end
end

Example: EnforcedStyle: compact

# good
# combine definitions as much as possible
class Foo::Bar
end

The compact style is only forced for classes/modules with one child.

Line is too long. [133/80]
Open

    states_result = State.select(:id, :abbreviation, 'countries.abbreviation as country_abbreviation').joins(:country).map do |state|
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

Useless protected access modifier.
Open

  protected
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

This cop checks for redundant access modifiers, including those with no code, those which are repeated, and leading public modifiers in a class or module body. Conditionally-defined methods are considered as always being defined, and thus access modifiers guarding such methods are not redundant.

Example:

class Foo
  public # this is redundant (default access is public)

  def method
  end

  private # this is not redundant (a method is defined)
  def method2
  end

  private # this is redundant (no following methods are defined)
end

Example:

class Foo
  # The following is not redundant (conditionally defined methods are
  # considered as always defining a method)
  private

  if condition?
    def method
    end
  end

  protected # this is not redundant (method is defined)

  define_method(:method2) do
  end

  protected # this is redundant (repeated from previous modifier)

  [1,2,3].each do |i|
    define_method("foo#{i}") do
    end
  end

  # The following is redundant (methods defined on the class'
  # singleton class are not affected by the public modifier)
  public

  def self.method3
  end
end

Example:

# Lint/UselessAccessModifier:
#   ContextCreatingMethods:
#     - concerning
require 'active_support/concern'
class Foo
  concerning :Bar do
    def some_public_method
    end

    private

    def some_private_method
    end
  end

  # this is not redundant because `concerning` created its own context
  private

  def some_other_private_method
  end
end

Example:

# Lint/UselessAccessModifier:
#   MethodCreatingMethods:
#     - delegate
require 'active_support/core_ext/module/delegation'
class Foo
  # this is not redundant because `delegate` creates methods
  private

  delegate :method_a, to: :method_b
end

Missing top-level class documentation comment.
Open

class Import::CityService < ImportService
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

This cop checks for missing top-level documentation of classes and modules. Classes with no body are exempt from the check and so are namespace modules - modules that have nothing in their bodies except classes, other modules, or constant definitions.

The documentation requirement is annulled if the class or module has a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the same for all its children.

Example:

# bad
class Person
  # ...
end

# good
# Description/Explanation of Person class
class Person
  # ...
end

Space inside } missing.
Open

    City.import cities, on_duplicate_key_update: {conflict_target: [:key], columns: columns}, validate: false
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

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

Example: EnforcedStyle: space

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

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

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

Example: EnforcedStyle: no_space

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

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

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

Example: EnforcedStyle: compact

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

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

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

Line is too long. [109/80]
Open

    countries = Hash[Country.select(:id, :abbreviation).map { |country| [country.abbreviation, country.id] }]
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

Line is too long. [99/80]
Open

    data = City.order(:name).joins(:country).left_joins(:state).left_joins(:timezone).select fields
Severity: Minor
Found in app/services/import/city_service.rb by rubocop

There are no issues that match your filters.

Category
Status