sparklemotion/nokogiri

View on GitHub

Showing 400 of 537 total issues

Method joinURI has 64 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  private static String
  joinURI(String baseURI, String relativeURI) throws URISyntaxException
  {
    String bscheme = null;
    String bauthority = null;
Severity: Major
Found in ext/java/nokogiri/internals/c14n/Canonicalizer11.java - About 2 hrs to fix

    Method handleAttributes has 63 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      @Override
      protected Iterator<Attr>
      handleAttributes(Element element, NameSpaceSymbTable ns)
      throws CanonicalizationException
      {
    Severity: Major
    Found in ext/java/nokogiri/internals/c14n/Canonicalizer11.java - About 2 hrs to fix

      Method addNode has 63 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        protected int
        addNode(Node node, int parentIndex,
                int previousSibling, int forceNodeType)
        {
          int nodeIndex = m_nodes.size();
      Severity: Major
      Found in ext/java/nokogiri/internals/dom2dtm/DOM2DTM.java - About 2 hrs to fix

        Method getAttributeNode has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
        Open

          public int
          getAttributeNode(int nodeHandle, String namespaceURI,
                           String name)
          {
        
        
        Severity: Minor
        Found in ext/java/nokogiri/internals/dom2dtm/DOM2DTM.java - 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 getUnparsedEntityURI has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
        Open

          public String
          getUnparsedEntityURI(String name)
          {
        
            String url = "";
        Severity: Minor
        Found in ext/java/nokogiri/internals/dom2dtm/DOM2DTM.java - 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 compile has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
        Open

              def compile
                cflags = concat_flags(ENV["CFLAGS"], "-fPIC", "-O2", "-g")
        
                env = { "CC" => gcc_cmd, "CFLAGS" => cflags }
                if config_cross_build?
        Severity: Minor
        Found in ext/nokogiri/extconf.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

        Class Document has 22 methods (exceeds 20 allowed). Consider refactoring.
        Open

            class Document < Nokogiri::XML::Node
              # See http://www.w3.org/TR/REC-xml-names/#ns-decl for more details. Note that we're not
              # attempting to handle unicode characters partly because libxml2 doesn't handle unicode
              # characters in NCNAMEs.
              NCNAME_START_CHAR = "A-Za-z_"
        Severity: Minor
        Found in lib/nokogiri/xml/document.rb - About 2 hrs to fix

          Method handleAttributes has 57 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            @Override
            protected Iterator<Attr>
            handleAttributes(Element element, NameSpaceSymbTable ns)
            throws CanonicalizationException
            {
          Severity: Major
          Found in ext/java/nokogiri/internals/c14n/Canonicalizer20010315.java - About 2 hrs to fix

            Method visit_function has 57 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                  def visit_function(node)
                    msg = :"visit_function_#{node.value.first.gsub(/[(]/, "")}"
                    return send(msg, node) if respond_to?(msg)
            
                    case node.value.first
            Severity: Major
            Found in lib/nokogiri/css/xpath_visitor.rb - About 2 hrs to fix

              File XmlSaxParserContext.java has 261 lines of code (exceeds 250 allowed). Consider refactoring.
              Open

              package nokogiri;
              
              import nokogiri.internals.*;
              import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
              
              
              Severity: Minor
              Found in ext/java/nokogiri/XmlSaxParserContext.java - About 2 hrs to fix

                File Canonicalizer20010315.java has 261 lines of code (exceeds 250 allowed). Consider refactoring.
                Open

                /**
                 * Licensed to the Apache Software Foundation (ASF) under one
                 * or more contributor license agreements. See the NOTICE file
                 * distributed with this work for additional information
                 * regarding copyright ownership. The ASF licenses this file
                Severity: Minor
                Found in ext/java/nokogiri/internals/c14n/Canonicalizer20010315.java - About 2 hrs to fix

                  Method outputPItoWriter has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
                  Open

                    protected void
                    outputPItoWriter(
                      ProcessingInstruction currentPI, OutputStream writer, int position
                    ) throws IOException
                    {
                  Severity: Minor
                  Found in ext/java/nokogiri/internals/c14n/CanonicalizerBase.java - 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 getHandleOfNode has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
                  Open

                    public int
                    getHandleOfNode(Node node)
                    {
                      if (null != node) {
                        // Is Node actually within the same document? If not, don't search!
                  Severity: Minor
                  Found in ext/java/nokogiri/internals/dom2dtm/DOM2DTM.java - 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 getElementById has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
                  Open

                    public int
                    getElementById(String elementId)
                    {
                  
                      Document doc = (m_root.getNodeType() == Node.DOCUMENT_NODE)
                  Severity: Minor
                  Found in ext/java/nokogiri/internals/dom2dtm/DOM2DTM.java - 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 resolveEntity has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
                  Open

                    protected InputSource
                    resolveEntity(Ruby runtime, String name, String publicId, String baseURI, String systemId)
                    throws IOException, SAXException
                    {
                      InputSource s = new InputSource();
                  Severity: Minor
                  Found in ext/java/nokogiri/internals/NokogiriEntityResolver.java - 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 count has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
                  Open

                    private boolean
                    count(Node node, int[] counter)
                    {
                      if (node == this.node) {
                        return true;
                  Severity: Minor
                  Found in ext/java/nokogiri/XmlNode.java - 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 getXmlBaseUri has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
                  Open

                      private String
                      getXmlBaseUri(String n, String v, Stack<String> xmlBaseStack)
                      {
                        if ("xml:base".equals(n)) {
                          if (v.startsWith("http://")) {
                  Severity: Minor
                  Found in ext/java/nokogiri/internals/ReaderNode.java - 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 parse has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
                  Open

                          def parse(
                            string_or_io,
                            url_ = nil, encoding_ = nil, options_ = XML::ParseOptions::DEFAULT_XML,
                            url: url_, encoding: encoding_, options: options_
                          )
                  Severity: Minor
                  Found in lib/nokogiri/xml/document.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 visit_element_name has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
                  Open

                        def visit_element_name(node)
                          if @doctype == DoctypeConfig::HTML5 && html5_element_name_needs_namespace_handling(node)
                            # HTML5 has namespaces that should be ignored in CSS queries
                            # https://github.com/sparklemotion/nokogiri/issues/2376
                            if @builtins == BuiltinsConfig::ALWAYS || (@builtins == BuiltinsConfig::OPTIMAL && Nokogiri.uses_libxml?)
                  Severity: Minor
                  Found in lib/nokogiri/css/xpath_visitor.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 constructNode has 56 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    public static IRubyObject
                    constructNode(Ruby runtime, Node node)
                    {
                      if (node == null) { return runtime.getNil(); }
                      // this is slow; need a way to cache nokogiri classes/modules somewhere
                  Severity: Major
                  Found in ext/java/nokogiri/internals/NokogiriHelpers.java - About 2 hrs to fix
                    Severity
                    Category
                    Status
                    Source
                    Language