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();
Method handleAttributes
has 63 lines of code (exceeds 25 allowed). Consider refactoring. Open
@Override
protected Iterator<Attr>
handleAttributes(Element element, NameSpaceSymbTable ns)
throws CanonicalizationException
{
Method getUnparsedEntityURI
has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring. Open
public String
getUnparsedEntityURI(String name)
{
String url = "";
- Read upRead up
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)
{
- Read upRead up
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_"
Method handleAttributes
has 57 lines of code (exceeds 25 allowed). Consider refactoring. Open
@Override
protected Iterator<Attr>
handleAttributes(Element element, NameSpaceSymbTable ns)
throws CanonicalizationException
{
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
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();
- Read upRead up
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)
- Read upRead up
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;
- Read upRead up
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!
- Read upRead up
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
{
- Read upRead up
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://")) {
- Read upRead up
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
- Read upRead up
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
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
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;
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.
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;
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;