Sign upLogin

codeRIT/hackathon_manager

View on GitHub
Star

Showing 147 of 151 total issues

Avoid too many return statements within this method.
Open

    return value.join(", ") if value.is_a? Array
Severity: Major
Found in app/helpers/audit_helper.rb - About 30 mins to fix

    Avoid too many return statements within this method.
    Open

        return display_datetime(value, relative: false) if value.is_a? Time
    Severity: Major
    Found in app/helpers/audit_helper.rb - About 30 mins to fix

      Similar blocks of code found in 3 locations. Consider refactoring.
      Open

        def data
    records.map do |record|
      {
        id: record.id,
        first_name: record.user.first_name,
      Severity: Minor
      Found in app/datatables/checked_in_datatable.rb and 2 other locations - About 25 mins to fix
      app/datatables/applied_datatable.rb on lines 18..28
      app/datatables/attendee_sponsor_info_datatable.rb on lines 18..28

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 31.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Similar blocks of code found in 3 locations. Consider refactoring.
      Open

        def data
    records.map do |record|
      {
        id: record.id,
        first_name: record.user.first_name,
      Severity: Minor
      Found in app/datatables/applied_datatable.rb and 2 other locations - About 25 mins to fix
      app/datatables/attendee_sponsor_info_datatable.rb on lines 18..28
      app/datatables/checked_in_datatable.rb on lines 18..28

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 31.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Similar blocks of code found in 3 locations. Consider refactoring.
      Open

        def data
    records.map do |record|
      {
        id: record.id,
        first_name: record.user.first_name,
      Severity: Minor
      Found in app/datatables/attendee_sponsor_info_datatable.rb and 2 other locations - About 25 mins to fix
      app/datatables/applied_datatable.rb on lines 18..28
      app/datatables/checked_in_datatable.rb on lines 18..28

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 31.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Method display_audit_value has a Cognitive Complexity of 8 (exceeds 7 allowed). Consider refactoring.
      Open

        def display_audit_value(value, field)
    return "(none)" if value.blank?
    return Questionnaire::POSSIBLE_ACC_STATUS[value] if field == "acc_status"
    return BusList.find(value)&.name || value if field == "bus_list_id"
    return User.find_by_id(value)&.full_name || "(deleted user)" if field == "checked_in_by_id"
      Severity: Minor
      Found in app/helpers/audit_helper.rb - About 25 mins to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

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

            format.html do
        redirect_to_checkins = params[:redirect_to_checkins] || false
        show_redirect_path = redirect_to_checkins ? manage_checkin_path(@questionnaire) : manage_questionnaire_path(@questionnaire)
        index_redirect_path = redirect_to_checkins ? manage_checkins_path : manage_questionnaires_path
        if params[:check_in] == "true"
      Severity: Minor
      Found in app/controllers/manage/questionnaires_controller.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.

      Method active_link_to has a Cognitive Complexity of 8 (exceeds 7 allowed). Consider refactoring.
      Open

        def active_link_to(name = nil, options = nil, html_options = nil, &block)
    # this is from Rails source - ignore rubocop
    # rubocop:disable Style/ParallelAssignment
    html_options, options, name = options, name, block if block_given?
    options ||= {}
      Severity: Minor
      Found in app/helpers/hackathon_manager_helper.rb - About 25 mins to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Similar blocks of code found in 2 locations. Consider refactoring.
      Open

        def vcs_url=(value)
    value = value.downcase unless value.blank?
    value = "https://" + value if !value.blank? && !value.include?("http://") && !value.include?("https://")
    super value
  end
      Severity: Minor
      Found in app/models/questionnaire.rb and 1 other location - About 20 mins to fix
      app/models/questionnaire.rb on lines 330..334

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 28.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Similar blocks of code found in 2 locations. Consider refactoring.
      Open

        def portfolio_url=(value)
    value = value.downcase unless value.blank?
    value = "http://" + value if !value.blank? && !value.include?("http://") && !value.include?("https://")
    super value
  end
      Severity: Minor
      Found in app/models/questionnaire.rb and 1 other location - About 20 mins to fix
      app/models/questionnaire.rb on lines 336..340

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 28.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Similar blocks of code found in 2 locations. Consider refactoring.
      Open

        POSSIBLE_SIMPLE_RECIPIENTS = {
    "all" => "Everyone",
    "incomplete" => "Incomplete Applications",
    "complete" => "Complete Applications",
    "accepted" => "Accepted Applications",
      Severity: Minor
      Found in app/models/message.rb and 1 other location - About 20 mins to fix
      app/models/message.rb on lines 32..44

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 27.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Similar blocks of code found in 2 locations. Consider refactoring.
      Open

        POSSIBLE_TRIGGERS = {
    "questionnaire.pending" => "Questionnaire Status: Pending Review (new application)",
    "questionnaire.accepted" => "Questionnaire Status: Accepted",
    "questionnaire.waitlist" => "Questionnaire Status: Waitlisted",
    "questionnaire.denied" => "Questionnaire Status: Denied",
      Severity: Minor
      Found in app/models/message.rb and 1 other location - About 20 mins to fix
      app/models/message.rb on lines 17..29

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 27.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Useless assignment to variable - ex.
      Open

          rescue => ex
      Severity: Minor
      Found in app/jobs/generate_data_export_job.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

          "denied"         => "Denied",
      Severity: Minor
      Found in app/models/questionnaire.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)
- ignore_explicit (with curly braces)

      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})

      Add empty line after guard clause.
      Open

          return if school.blank?
      Severity: Minor
      Found in app/models/questionnaire.rb by rubocop

      This cop enforces empty line after guard clause

      Example:

      # bad
def foo
  return if need_return?
  bar
end

# good
def foo
  return if need_return?

  bar
end

# good
def foo
  return if something?
  return if something_different?

  bar
end

# also good
def foo
  if something?
    do_something
    return if need_return?
  end
end

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

                range:         :bootstrap_vertical_range,
      Severity: Minor
      Found in app/helpers/manage/bootstrap_form_helper.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)
- ignore_explicit (with curly braces)

      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

                file:          :bootstrap_vertical_file,
      Severity: Minor
      Found in app/helpers/manage/bootstrap_form_helper.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)
- ignore_explicit (with curly braces)

      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})

      Use School.where("questionnaire_count >= 5").count.positive? instead of School.where("questionnaire_count >= 5").count > 0.
      Open

          if School.where("questionnaire_count >= 5").count > 0
      Severity: Minor
      Found in app/controllers/manage/dashboard_controller.rb by rubocop

      This cop checks for usage of comparison operators (==, >, <) to test numbers as zero, positive, or negative. These can be replaced by their respective predicate methods. The cop can also be configured to do the reverse.

      The cop disregards #nonzero? as it its value is truthy or falsey, but not true and false, and thus not always interchangeable with != 0.

      The cop ignores comparisons to global variables, since they are often populated with objects which can be compared with integers, but are not themselves Integer polymorphic.

      Example: EnforcedStyle: predicate (default)

      # bad

foo == 0
0 > foo
bar.baz > 0

# good

foo.zero?
foo.negative?
bar.baz.positive?

      Example: EnforcedStyle: comparison

      # bad

foo.zero?
foo.negative?
bar.baz.positive?

# good

foo == 0
0 > foo
bar.baz > 0

      Rule doesn't have all its properties in alphabetical order.
      Open

      .gridBlock .twoByGridBlock {
      Severity: Minor
      Found in website/static/css/custom.css by csslint

      Use of !important
      Open

          display: block !important;
      Severity: Minor
      Found in website/static/css/custom.css by csslint
      Severity
      Category
      Status
      Source
      Language