File query_clauses.rb has 584 lines of code (exceeds 250 allowed). Consider refactoring.

Open

module Neo4j
  module Core
    module QueryClauses
      class ArgError < StandardError
        attr_reader :arg_part

Class Query has 33 methods (exceeds 20 allowed). Consider refactoring.

Open

    class Query
      include Neo4j::Core::QueryClauses
      include Neo4j::Core::QueryFindInBatches
      DEFINED_CLAUSES = {}

Class Clause has 27 methods (exceeds 20 allowed). Consider refactoring.

Open

      class Clause
        UNDERSCORE = '_'
        COMMA_SPACE = ', '
        AND = ' AND '
        PRETTY_NEW_LINE = "\n  "

Class Label has 25 methods (exceeds 20 allowed). Consider refactoring.

Open

    class Label
      attr_reader :name

      def initialize(name, session)
        @name = name

File query.rb has 278 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require 'neo4j/core/query_clauses'
require 'neo4j/core/query_find_in_batches'
require 'active_support/notifications'

module Neo4j

Method run has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    def run(*args)
      session, run_in_tx = session_and_run_in_tx_from_args(args)

      fail ArgumentError, 'Expected a block to run in Transaction.run' unless block_given?

• Read up
  Read up

Method generate_partitioning! has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

        def generate_partitioning!
          @partitioning = [[]]

          @clauses.each do |clause|
            if clause.nil? && !fresh_partition?

• Read up
  Read up

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

Open

        def value
          return @value if @value

          [String, Symbol, Integer, Hash, NilClass].each do |arg_class|
            from_method = "from_#{arg_class.name.downcase}"

• Read up
  Read up

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

Open

          def clause_strings(clauses)
            clauses.flat_map do |clause|
              Array(clause.value).map do |v|
                (clause.options[:not] ? 'NOT' : '') + (v.to_s.match(PAREN_SURROUND_REGEX) ? v.to_s : "(#{v})")
              end

• Read up
  Read up

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

Open

        def key_value_string(key, value, previous_keys = [], is_set = false)
          param = (previous_keys << key).join(UNDERSCORE)
          self.class.paramaterize_key!(param)

          if value.is_a?(Range)

• Read up
  Read up

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

Open

      def each
        response = self.response
        if defined?(Neo4j::Server::CypherResponse) && response.is_a?(Neo4j::Server::CypherResponse)
          response.unwrapped! if unwrapped?
          response.to_node_enumeration

• Read up
  Read up

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

Open

        def hash_key_value_string(key, value, previous_keys)
          value.map do |k, v|
            if k.to_sym == :neo_id
              v = Array(v).map { |item| (item.respond_to?(:neo_id) ? item.neo_id : item).to_i }
              key_value_string("ID(#{key})", v)

• Read up
  Read up

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

Open

          def _wrap_entity(entity)
            case @wrap_level
            when :none then wrap_value(entity)
            when :core_entity, :proc
              if type = type_for_entity(entity)

• Read up
  Read up

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

Open

          def initialize(*args)
            super
            return unless root?
            @driver_session = session.adaptor.driver.session(Neo4j::Driver::AccessMode::WRITE)
            @driver_tx = @driver_session.begin_transaction

• Read up
  Read up

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

Open

      def initialize(id, type, properties, start_node_id = nil, end_node_id = nil)

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

Open

          def wrap_relationship(id, from_node_id, to_node_id, type, properties)

Method format_label has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

        def format_label(label_arg)
          return label_arg.map { |arg| format_label(arg) }.join if label_arg.is_a?(Array)

          label_arg = label_arg.to_s.strip
          if !label_arg.empty? && label_arg[0] != ':'

• Read up
  Read up

Method from_args has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

          def from_args(args, params, options = {})
            query_string, params_arg = args

            if query_string.is_a?(String) && (query_string.match(ARG_HAS_QUESTION_MARK_REGEX) || params_arg.is_a?(Hash))
              if params_arg.is_a?(Hash)

• Read up
  Read up

Method session_and_run_in_tx_from_args has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def session_and_run_in_tx_from_args(args)
      fail ArgumentError, 'Too few arguments' if args.empty?
      fail ArgumentError, 'Too many arguments' if args.size > 2

      if args.size == 1

• Read up
  Read up

Method response has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def response
        return @response if @response

        @response = if session_is_new_api?
                      @session.query(self, transaction: Transaction.current_for(@session), wrap_level: (:core_entity if unwrapped?))

• Read up
  Read up