Sign upLogin

ManageIQ/azure-armrest

View on GitHub
Star
lib/azure/armrest/model/storage_account.rb

Summary

Maintainability
F
4 days
Test Coverage
F
30%

File storage_account.rb has 571 lines of code (exceeds 250 allowed). Consider refactoring.
Open

require 'azure-signature'
require 'active_support'
require 'active_support/core_ext/hash/conversions'

module Azure
Severity: Major
Found in lib/azure/armrest/model/storage_account.rb - About 1 day to fix

    Class StorageAccount has 36 methods (exceeds 20 allowed). Consider refactoring.
    Open

        class StorageAccount < BaseModel
      attr_from_hash :name          => :name,
                     :blob_endpoint => [:properties, :primaryEndpoints, :blob]

      # Classes used to wrap container and blob information.
    Severity: Minor
    Found in lib/azure/armrest/model/storage_account.rb - About 4 hrs to fix

      Method create_blob has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
      Open

            def create_blob(container, blob, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        timeout = options.delete(:timeout)
        payload = options.delete(:payload) || ''
      Severity: Minor
      Found in lib/azure/armrest/model/storage_account.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

      Cyclomatic complexity for create_blob is too high. [14/11]
      Open

            def create_blob(container, blob, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        timeout = options.delete(:timeout)
        payload = options.delete(:payload) || ''
      Severity: Minor
      Found in lib/azure/armrest/model/storage_account.rb by rubocop

      Checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.

      An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one. Blocks that are calls to builtin iteration methods (e.g. `ary.map{...}) also add one, others are ignored.

      def each_child_node(*types)               # count begins: 1
  unless block_given?                     # unless: +1
    return to_enum(__method__, *types)

  children.each do |child|                # each{}: +1
    next unless child.is_a?(Node)         # unless: +1

    yield child if types.empty? ||        # if: +1, ||: +1
                   types.include?(child.type)
  end

  self
end                                       # total: 6

      Cyclomatic complexity for files is too high. [12/11]
      Open

            def files(share, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        query = "comp=list&restype=directory"
      Severity: Minor
      Found in lib/azure/armrest/model/storage_account.rb by rubocop

      Checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.

      An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one. Blocks that are calls to builtin iteration methods (e.g. `ary.map{...}) also add one, others are ignored.

      def each_child_node(*types)               # count begins: 1
  unless block_given?                     # unless: +1
    return to_enum(__method__, *types)

  children.each do |child|                # each{}: +1
    next unless child.is_a?(Node)         # unless: +1

    yield child if types.empty? ||        # if: +1, ||: +1
                   types.include?(child.type)
  end

  self
end                                       # total: 6

      Method build_query has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
      Open

            def build_query(options)
        array = []

        options.each do |key, value|
          next if key == :all
      Severity: Minor
      Found in lib/azure/armrest/model/storage_account.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

      Method create_blob has 40 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

            def create_blob(container, blob, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        timeout = options.delete(:timeout)
        payload = options.delete(:payload) || ''
      Severity: Minor
      Found in lib/azure/armrest/model/storage_account.rb - About 1 hr to fix

        Method get_blob_raw has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
        Open

              def get_blob_raw(container, blob, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        url = File.join(properties.primary_endpoints.blob, container, blob)
        url += "?snapshot=" + options[:date] if options[:date]
        Severity: Minor
        Found in lib/azure/armrest/model/storage_account.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

        Method blobs has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
        Open

              def blobs(container, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        query = "restype=container&comp=list"
        skip_defs = options[:skip_accessors_definition]
        Severity: Minor
        Found in lib/azure/armrest/model/storage_account.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

        Method get_blob_raw has 33 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

              def get_blob_raw(container, blob, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        url = File.join(properties.primary_endpoints.blob, container, blob)
        url += "?snapshot=" + options[:date] if options[:date]
        Severity: Minor
        Found in lib/azure/armrest/model/storage_account.rb - About 1 hr to fix

          Method add_file_content has 30 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

                def add_file_content(share, file, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        timeout = options.delete(:timeout)
        content = options.delete(:content)
          Severity: Minor
          Found in lib/azure/armrest/model/storage_account.rb - About 1 hr to fix

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

                  def files(share, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        query = "comp=list&restype=directory"
            Severity: Minor
            Found in lib/azure/armrest/model/storage_account.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

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

                  def create_blob_snapshot(container, blob, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        timeout = options.delete(:timeout) # Part of request
            Severity: Minor
            Found in lib/azure/armrest/model/storage_account.rb - About 1 hr to fix

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

                    def containers(key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        query = "comp=list"
        skip_defs = options[:skip_accessors_definition]
              Severity: Minor
              Found in lib/azure/armrest/model/storage_account.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 copy_blob has 5 arguments (exceeds 4 allowed). Consider refactoring.
              Open

                    def copy_blob(src_container, src_blob, dst_container, dst_blob = nil, key = access_key)
              Severity: Minor
              Found in lib/azure/armrest/model/storage_account.rb - About 35 mins to fix

                Method file_response has 5 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                      def file_response(key, query, request_type = 'get', payload = '', *args)
                Severity: Minor
                Found in lib/azure/armrest/model/storage_account.rb - About 35 mins to fix

                  Method copy_file has 5 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                        def copy_file(src_container, src_file, dst_container = src_container, dst_file = nil, key = access_key)
                  Severity: Minor
                  Found in lib/azure/armrest/model/storage_account.rb - About 35 mins to fix

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

                          def add_file_content(share, file, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        timeout = options.delete(:timeout)
        content = options.delete(:content)
                    Severity: Minor
                    Found in lib/azure/armrest/model/storage_account.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 create_blob_snapshot has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                    Open

                          def create_blob_snapshot(container, blob, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        timeout = options.delete(:timeout) # Part of request
                    Severity: Minor
                    Found in lib/azure/armrest/model/storage_account.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

                    Use match? instead of =~ when MatchData is not used.
                    Open

                              if okey.to_s =~ /^if/i
                    Severity: Minor
                    Found in lib/azure/armrest/model/storage_account.rb by rubocop

                    In Ruby 2.4, String#match?, Regexp#match? and Symbol#match? have been added. The methods are faster than match. Because the methods avoid creating a MatchData object or saving backref. So, when MatchData is not used, use match? instead of match.

                    Example:

                    # bad
def foo
  if x =~ /re/
    do_something
  end
end

# bad
def foo
  if x.match(/re/)
    do_something
  end
end

# bad
def foo
  if /re/ === x
    do_something
  end
end

# good
def foo
  if x.match?(/re/)
    do_something
  end
end

# good
def foo
  if x =~ /re/
    do_something(Regexp.last_match)
  end
end

# good
def foo
  if x.match(/re/)
    do_something($~)
  end
end

# good
def foo
  if /re/ === x
    do_something($~)
  end
end

                    Avoid immutable Array literals in loops. It is better to extract it into a local variable or a constant.
                    Open

                              if [:filter, :select, :top].include?(key)
                    Severity: Minor
                    Found in lib/azure/armrest/model/storage_account.rb by rubocop

                    Use match? instead of =~ when MatchData is not used.
                    Open

                              if okey.to_s =~ /^if/i
                    Severity: Minor
                    Found in lib/azure/armrest/model/storage_account.rb by rubocop

                    In Ruby 2.4, String#match?, Regexp#match? and Symbol#match? have been added. The methods are faster than match. Because the methods avoid creating a MatchData object or saving backref. So, when MatchData is not used, use match? instead of match.

                    Example:

                    # bad
def foo
  if x =~ /re/
    do_something
  end
end

# bad
def foo
  if x.match(/re/)
    do_something
  end
end

# bad
def foo
  if /re/ === x
    do_something
  end
end

# good
def foo
  if x.match?(/re/)
    do_something
  end
end

# good
def foo
  if x =~ /re/
    do_something(Regexp.last_match)
  end
end

# good
def foo
  if x.match(/re/)
    do_something($~)
  end
end

# good
def foo
  if /re/ === x
    do_something($~)
  end
end

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

                          def create_directory(share, directory, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        query = {:restype => 'directory'}.merge(options).to_query
                    Severity: Minor
                    Found in lib/azure/armrest/model/storage_account.rb and 1 other location - About 45 mins to fix
                    lib/azure/armrest/model/storage_account.rb on lines 147..155

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

                    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 delete_directory(share, directory, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        query = {:restype => 'directory'}.merge(options).to_query
                    Severity: Minor
                    Found in lib/azure/armrest/model/storage_account.rb and 1 other location - About 45 mins to fix
                    lib/azure/armrest/model/storage_account.rb on lines 131..139

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

                    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 file_properties(share, file, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        query = options.to_query
                    Severity: Minor
                    Found in lib/azure/armrest/model/storage_account.rb and 1 other location - About 40 mins to fix
                    lib/azure/armrest/model/storage_account.rb on lines 323..331

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

                    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 delete_file(share, file, key = access_key, options = {})
        raise ArgumentError, "No access key specified" unless key

        query = options.to_query
                    Severity: Minor
                    Found in lib/azure/armrest/model/storage_account.rb and 1 other location - About 40 mins to fix
                    lib/azure/armrest/model/storage_account.rb on lines 255..263

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

                    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

                    Wrap expressions with varying precedence with parentheses to avoid ambiguity.
                    Open

                            query << "&snapshot=" + options[:date] if options[:date]
                    Severity: Minor
                    Found in lib/azure/armrest/model/storage_account.rb by rubocop

                    Looks for expressions containing multiple binary operators where precedence is ambiguous due to lack of parentheses. For example, in 1 + 2 * 3, the multiplication will happen before the addition, but lexically it appears that the addition will happen first.

                    The cop does not consider unary operators (ie. !a or -b) or comparison operators (ie. a =~ b) because those are not ambiguous.

                    NOTE: Ranges are handled by Lint/AmbiguousRange.

                    Example:

                    # bad
a + b * c
a || b && c
a ** b + c

# good (different precedence)
a + (b * c)
a || (b && c)
(a ** b) + c

# good (same precedence)
a + b + c
a * b / c % d

                    There are no issues that match your filters.

                    Category
                    Status