Sign upLogin

gitshowcase/gitshowcase

View on GitHub
Star

Showing 883 of 883 total issues

Method set has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
Open

  def set(skills)
    keys = skills.keys
    skills = convert_from_arrays(skills) if keys.size == 2 && keys.include?(:name) && keys.include?(:mastery)

    parsed = {}
Severity: Minor
Found in app/services/user/skills_service.rb - About 1 hr 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. [34/25]
Open

RSpec.shared_examples 'social_networks' do
  describe 'included' do
    subject(:user) { described_class.new(linkedin: 'http://linkedin.com/in/john_in') }

    it 'creates getter' do
Severity: Minor
Found in spec/models/concerns/social_networks_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.

Method change has 26 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  def change
    add_column :users, :name, :string
    add_column :users, :username, :string
    add_column :users, :avatar, :string
    add_column :users, :cover, :string
Severity: Minor
Found in db/migrate/20170111021222_add_info_to_user.rb - About 1 hr to fix

    Method set has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
    Open

      def set(field, value)
    field = field.to_sym

    field = :socials if User::SOCIALS.key?(field)
    return unless FIELDS.key? field
    Severity: Minor
    Found in app/services/user/completeness_service.rb - About 55 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. [30/25]
    Open

      create_table "snapshots", force: :cascade do |t|
    t.date     "date",                                                    null: false
    t.integer  "count_users",                               default: 0,   null: false
    t.integer  "count_projects",                            default: 0,   null: false
    t.integer  "count_domains",                             default: 0,   null: false
    Severity: Minor
    Found in db/schema.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. [30/25]
    Open

    RSpec.describe Project do
  # Foreign Keys
  it { should belong_to(:user) }

  describe '#display_title' do
    Severity: Minor
    Found in spec/models/project_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. [30/25]
    Open

      context 'enabled' do
    let!(:client_member) { double.as_null_object }

    before {
      allow(EmailSubscriptionService).to receive(:enabled?).and_return(true)
    Severity: Minor
    Found in spec/services/email_subscription_service_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. [29/25]
    Open

        create_table :snapshots do |t|
      t.date :date, null: false

      # Total values
      t.integer :count_users, null: false, default: 0
    Severity: Minor
    Found in db/migrate/20170502201750_create_snapshots.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. [29/25]
    Open

          namespace :dashboard do
        controller :users do
          get '/', action: :home, as: :home

          get 'domain'
    Severity: Minor
    Found in config/routes.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. [29/25]
    Open

      describe '#sync' do
    subject(:service) { ProjectInspectorService.new(project) }

    context 'without homepage' do
      let(:project) { FactoryGirl.build(:project, id: 0, title: 'title') }
    Severity: Minor
    Found in spec/services/project_inspector_service_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.

    Method update_domain has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
    Open

      def update_domain
    old_domain = @user.domain
    new_domain = user_params(:domain)[:domain]

    if old_domain != new_domain
    Severity: Minor
    Found in app/controllers/dashboard/users_controller.rb - About 35 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

    Method website_url has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
    Open

      def self.website_url(website, path, protocol = 'http')
    return nil unless path.present?
    return path if is_url(path)
    return url(path, protocol) if !website.present? || path.include?(extract(website))
    Severity: Minor
    Found in app/helpers/url_helper.rb - About 35 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. [28/25]
    Open

        context 'with repository' do
      let(:project) { FactoryGirl.build(:project, repository: 'gitshowcase/gitshowcase') }

      it 'fetches repository data' do
        client = double
    Severity: Minor
    Found in spec/services/github_project_service_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.

    Loofah 2.0.3 is vulnerable (CVE-2018-8048). Upgrade to 2.1.2
    Open

        loofah (2.0.3)
    Severity: Minor
    Found in Gemfile.lock by brakeman

    Read more: https://github.com/flavorjones/loofah/issues/144

    Possible SQL injection
    Open

            query = query.where("(#{where.join(' OR ')})", *values)
    Severity: Minor
    Found in app/controllers/admin/users_controller.rb by brakeman

    Injection is #1 on the 2013 OWASP Top Ten web security risks. SQL injection is when a user is able to manipulate a value which is used unsafely inside a SQL query. This can lead to data leaks, data loss, elevation of privilege, and other unpleasant outcomes.

    Brakeman focuses on ActiveRecord methods dealing with building SQL statements.

    A basic (Rails 2.x) example looks like this:

    User.first(:conditions => "username = '#{params[:username]}'")

    Brakeman would produce a warning like this:

    Possible SQL injection near line 30: User.first(:conditions => ("username = '#{params[:username]}'"))

    The safe way to do this query is to use a parameterized query:

    User.first(:conditions => ["username = ?", params[:username]])

    Brakeman also understands the new Rails 3.x way of doing things (and local variables and concatenation):

    username = params[:user][:name].downcase
password = params[:user][:password]

User.first.where("username = '" + username + "' AND password = '" + password + "'")

    This results in this kind of warning:

    Possible SQL injection near line 37:
User.first.where((((("username = '" + params[:user][:name].downcase) + "' AND password = '") + params[:user][:password]) + "'"))

    See the Ruby Security Guide for more information and Rails-SQLi.org for many examples of SQL injection in Rails.

    rails-html-sanitizer 1.0.3 is vulnerable (CVE-2018-3741). Upgrade to 1.0.4
    Open

        rails-html-sanitizer (1.0.3)
    Severity: Minor
    Found in Gemfile.lock by brakeman

    Read more: https://groups.google.com/d/msg/rubyonrails-security/tP7W3kLc5u4/uDy2Br7xBgAJ

    Possible SQL injection
    Open

          query = query.where("(#{fields.join(' OR ')})", *(["%#{@filters[:search]}%"] * fields.count))
    Severity: Minor
    Found in app/controllers/admin/users_controller.rb by brakeman

    Injection is #1 on the 2013 OWASP Top Ten web security risks. SQL injection is when a user is able to manipulate a value which is used unsafely inside a SQL query. This can lead to data leaks, data loss, elevation of privilege, and other unpleasant outcomes.

    Brakeman focuses on ActiveRecord methods dealing with building SQL statements.

    A basic (Rails 2.x) example looks like this:

    User.first(:conditions => "username = '#{params[:username]}'")

    Brakeman would produce a warning like this:

    Possible SQL injection near line 30: User.first(:conditions => ("username = '#{params[:username]}'"))

    The safe way to do this query is to use a parameterized query:

    User.first(:conditions => ["username = ?", params[:username]])

    Brakeman also understands the new Rails 3.x way of doing things (and local variables and concatenation):

    username = params[:user][:name].downcase
password = params[:user][:password]

User.first.where("username = '" + username + "' AND password = '" + password + "'")

    This results in this kind of warning:

    Possible SQL injection near line 37:
User.first.where((((("username = '" + params[:user][:name].downcase) + "' AND password = '") + params[:user][:password]) + "'"))

    See the Ruby Security Guide for more information and Rails-SQLi.org for many examples of SQL injection in Rails.

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

      context 'disabled' do
    before { allow(DomainService).to receive(:enabled?).and_return(false) }

    describe '#initialize' do
      it 'raises' do
    Severity: Minor
    Found in spec/services/domain_service_spec.rb and 1 other location - About 20 mins to fix
    spec/services/email_subscription_service_spec.rb on lines 44..49

    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

      context 'disabled' do
    before { allow(EmailSubscriptionService).to receive(:enabled?).and_return(false) }

    describe '#initialize' do
      it 'raises message' do
    Severity: Minor
    Found in spec/services/email_subscription_service_spec.rb and 1 other location - About 20 mins to fix
    spec/services/domain_service_spec.rb on lines 78..83

    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

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

              prefix: 'dribbble.com',
    Severity: Minor
    Found in app/models/concerns/social_networks.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
                        }
    Severity
    Category
    Status
    Source
    Language