Sign upLogin

binarybabel/latestver

View on GitHub
Star

Showing 20 of 20 total issues

Method view has a Cognitive Complexity of 32 (exceeds 5 allowed). Consider refactoring.
Open

  def view
    cache_this!
    @entry = CatalogEntry.find_by!(name: params[:name], tag: params[:tag])

    @data = @entry.api_data
Severity: Minor
Found in app/controllers/catalog_controller.rb - About 4 hrs 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

File catalog_entry.rb has 364 lines of code (exceeds 250 allowed). Consider refactoring.
Open

require 'mixlib/versioning'

class CatalogEntry < ActiveRecord::Base
  validates_presence_of :type
  validates :name, :tag, presence: true,
Severity: Minor
Found in app/models/catalog_entry.rb - About 4 hrs to fix

    Method configure_admin has 106 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      def self.configure_admin(klass)
    klass.rails_admin do
      label klass.to_s.demodulize.titleize
      navigation_label I18n.t 'app.nav.catalog'
      object_label_method do
    Severity: Major
    Found in app/models/catalog_entry.rb - About 4 hrs to fix

      Class CatalogEntry has 29 methods (exceeds 20 allowed). Consider refactoring.
      Open

      class CatalogEntry < ActiveRecord::Base
  validates_presence_of :type
  validates :name, :tag, presence: true,
            format: {with: /\A[a-z0-9][a-z0-9_\.-]+[a-z0-9]\z/i, message: 'allows letters, numbers, hyphens, underscores, and full-stops.'}
  validates :tag, uniqueness: {scope: :name}
      Severity: Minor
      Found in app/models/catalog_entry.rb - About 3 hrs to fix

        Method refresh! has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
        Open

          def refresh!
    begin
      v = check_remote_version
      unless v.kind_of?(FalseClass)
        if (v.kind_of?(String) and not v.empty?) or (v.kind_of?(Hash) and not v[:version].to_s.empty?)
        Severity: Minor
        Found in app/models/catalog_entry.rb - About 2 hrs 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 output has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
        Open

            def self.output(options, data)
      data_out = data

      unless data_out.is_a? Exception
        Severity: Minor
        Found in rubygem/lib/latestver/cli_helpers.rb - About 2 hrs 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 view has 53 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          def view
    cache_this!
    @entry = CatalogEntry.find_by!(name: params[:name], tag: params[:tag])

    @data = @entry.api_data
        Severity: Major
        Found in app/controllers/catalog_controller.rb - About 2 hrs to fix

          Method refresh! has 39 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            def refresh!
    begin
      v = check_remote_version
      unless v.kind_of?(FalseClass)
        if (v.kind_of?(String) and not v.empty?) or (v.kind_of?(Hash) and not v[:version].to_s.empty?)
          Severity: Minor
          Found in app/models/catalog_entry.rb - About 1 hr to fix

            Method output has 31 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                def self.output(options, data)
      data_out = data

      unless data_out.is_a? Exception
            Severity: Minor
            Found in rubygem/lib/latestver/cli_helpers.rb - About 1 hr to fix

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

                def update
    index
    Instance.transaction do
      @instances.each do |i|
        k = "ver_#{i.id}".to_sym
              Severity: Minor
              Found in app/controllers/group_controller.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

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

                  def check_remote_version
      text = fetch_remote_text

      iexp = Regexp.new(include_regex.to_s)
      xexp = Regexp.new(exclude_regex.to_s)
              Severity: Minor
              Found in app/models/catalog/web_scraper.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

              Method fetch_remote_text has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
              Open

                  def fetch_remote_text
      url = web_page_url.to_s.gsub(/%(?!\{)/, '%%') % template_params
      text = open(url) { |f| f.read }

      unless [css_query, xpath_query].all? { |v| v.to_s.empty? }
              Severity: Minor
              Found in app/models/catalog/web_scraper.rb - About 45 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

              Consider simplifying this complex logical expression.
              Open

                      if (v.kind_of?(String) and not v.empty?) or (v.kind_of?(Hash) and not v[:version].to_s.empty?)
          v0 = version.presence
          v1 = std_version(v.kind_of?(Hash) && v[:version] || v)

          CatalogEntry.transaction do
              Severity: Major
              Found in app/models/catalog_entry.rb - About 40 mins to fix

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

                          pretty_value do
            v = bindings[:view]
            o = bindings[:object]
            am = ::RailsAdmin::AbstractModel.new(o.class)
            v.link_to(value, v.url_for(action: :edit, model_name: am.to_param, id: o.id), class: 'pjax').html_safe
                Severity: Minor
                Found in app/models/catalog_entry.rb and 1 other location - About 35 mins to fix
                app/models/catalog_entry.rb on lines 364..368

                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 35.

                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

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

                          pretty_value do
            v = bindings[:view]
            o = bindings[:object]
            am = ::RailsAdmin::AbstractModel.new(o.class)
            v.link_to(value, v.url_for(action: :edit, model_name: am.to_param, id: o.id), class: 'pjax').html_safe
                Severity: Minor
                Found in app/models/catalog_entry.rb and 1 other location - About 35 mins to fix
                app/models/catalog_entry.rb on lines 372..376

                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 35.

                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 api has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                Open

                  def api
    cache_this!

    # Attempt to use latest values for examples.
    begin
                Severity: Minor
                Found in app/controllers/help_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 gem_version has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                Open

                    def gem_version(name, filter=nil)
      versions = Gems.versions(name)
      raise 'Failed to retrieve gem info.' unless versions
      raise versions.to_s unless versions.is_a?(Array)
      if filter
                Severity: Minor
                Found in app/models/catalog/ruby_gem.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

                Method check_remote_version has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                Open

                    def check_remote_version
      case tag
      when /jdk[0-9]|jre[0-9]/
        raise "Unknown Java tag (#{tag})" unless vendor_urls.include?(tag)
        major = scan_number(tag)
                Severity: Minor
                Found in app/models/catalog/oracle_java.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

                Method templated has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                Open

                  def templated(name)
    template = self.send(name)
    template = template.to_s.gsub(/%(?!\{)/, '%%')
    params = template_params
    counter = 0
                Severity: Minor
                Found in app/models/catalog_entry.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

                Method match_requirement has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                Open

                  def match_requirement(list, requirement)
    cache = Hash.new
    list = list.map do |y|
      begin
        scan_version_cache(y, cache, true)
                Severity: Minor
                Found in app/models/catalog_entry.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

                Severity
                Category
                Status
                Source
                Language