sparklemotion/nokogiri

View on GitHub

Showing 400 of 533 total issues

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

      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

          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 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 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 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 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 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 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 = ParseOptions::DEFAULT_XML)
                      options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
                      yield options if block_given?
            
                      url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
            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 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

              Method visit_function has 56 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

                Method relink_namespace has 55 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  public void
                  relink_namespace(ThreadContext context)
                  {
                    if (!(node instanceof Element)) {
                      return;
                Severity: Major
                Found in ext/java/nokogiri/XmlNode.java - About 2 hrs to fix

                  File xpath_visitor.rb has 258 lines of code (exceeds 250 allowed). Consider refactoring.
                  Open

                  module Nokogiri
                    module CSS
                      # When translating CSS selectors to XPath queries with Nokogiri::CSS.xpath_for, the XPathVisitor
                      # class allows for changing some of the behaviors related to builtin xpath functions and quirks
                      # of HTML5.
                  Severity: Minor
                  Found in lib/nokogiri/css/xpath_visitor.rb - About 2 hrs to fix

                    XmlSaxParserContext has 21 methods (exceeds 20 allowed). Consider refactoring.
                    Open

                    @JRubyClass(name = "Nokogiri::XML::SAX::ParserContext")
                    public class XmlSaxParserContext extends ParserContext
                    {
                      private static final long serialVersionUID = 1L;
                    
                    
                    Severity: Minor
                    Found in ext/java/nokogiri/XmlSaxParserContext.java - About 2 hrs to fix

                      Method node_type has 54 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                        @JRubyMethod(name = {"node_type", "type"})
                        public IRubyObject
                        node_type(ThreadContext context)
                        {
                          String type;
                      Severity: Major
                      Found in ext/java/nokogiri/XmlNode.java - About 2 hrs to fix
                        Severity
                        Category
                        Status
                        Source
                        Language