neo4jrb/neo4j

Very high overall complexity: 311

module Neo4j
  module ActiveNode
    module Query
      # rubocop:disable Metrics/ModuleLength
      module QueryProxyMethods

When classes take on too many responsibilities, they grow. A large number of instance variables or methods can make a class hard to understand. Large classes tend to have lower cohesion and higher churn.

Often large classes have methods that do not operate on all of the class state. Identifying the groups of data that are used together can point to seams to split out additional collaborator classes or value objects.

Another trick is to look for repeated prefixes or suffixes in method and variable names, or repeated parameter names, and use them to guide extractions.

Refactorings

Further Reading

Very high overall complexity: 296

module Neo4j
  module ActiveNode
    module Query
      # rubocop:disable Metrics/ClassLength
      class QueryProxy

When classes take on too many responsibilities, they grow. A large number of instance variables or methods can make a class hard to understand. Large classes tend to have lower cohesion and higher churn.

Often large classes have methods that do not operate on all of the class state. Identifying the groups of data that are used together can point to seams to split out additional collaborator classes or value objects.

Another trick is to look for repeated prefixes or suffixes in method and variable names, or repeated parameter names, and use them to guide extractions.

Refactorings

Further Reading

Very high overall complexity: 284

module Neo4j::ActiveNode
  module HasN
    extend ActiveSupport::Concern

    class NonPersistedNodeError < Neo4j::Error; end

When classes take on too many responsibilities, they grow. A large number of instance variables or methods can make a class hard to understand. Large classes tend to have lower cohesion and higher churn.

Often large classes have methods that do not operate on all of the class state. Identifying the groups of data that are used together can point to seams to split out additional collaborator classes or value objects.

Another trick is to look for repeated prefixes or suffixes in method and variable names, or repeated parameter names, and use them to guide extractions.

Refactorings

Further Reading

Very high overall complexity: 277

require 'active_support/inflector/inflections'
require 'neo4j/class_arguments'

module Neo4j
  module ActiveNode

When classes take on too many responsibilities, they grow. A large number of instance variables or methods can make a class hard to understand. Large classes tend to have lower cohesion and higher churn.

Often large classes have methods that do not operate on all of the class state. Identifying the groups of data that are used together can point to seams to split out additional collaborator classes or value objects.

Another trick is to look for repeated prefixes or suffixes in method and variable names, or repeated parameter names, and use them to guide extractions.

Refactorings

Further Reading

Identical code found in 1 other location

module Neo4j::ActiveNode
  module HasN
    extend ActiveSupport::Concern

    class NonPersistedNodeError < Neo4j::Error; end
lib/neo4j/active_node/has_n.rb on lines 387..390

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

Refactorings

Further Reading

Identical code found in 1 other location

module Neo4j::ActiveNode
  module HasN
    extend ActiveSupport::Concern

    class NonPersistedNodeError < Neo4j::Error; end
lib/neo4j/active_node/has_n.rb on lines 430..433

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

Refactorings

Further Reading

High overall complexity: 228

module Neo4j::Shared
  # rubocop:disable Metrics/ModuleLength
  module Persistence
    # rubocop:enable Metrics/ModuleLength
    extend ActiveSupport::Concern

When classes take on too many responsibilities, they grow. A large number of instance variables or methods can make a class hard to understand. Large classes tend to have lower cohesion and higher churn.

Often large classes have methods that do not operate on all of the class state. Identifying the groups of data that are used together can point to seams to split out additional collaborator classes or value objects.

Another trick is to look for repeated prefixes or suffixes in method and variable names, or repeated parameter names, and use them to guide extractions.

Refactorings

Further Reading

Identical code found in 1 other location

require 'neo4j/core/label'

module Neo4j
  module ActiveNode
    # Provides a mapping between neo4j labels and Ruby classes
lib/neo4j/active_rel/types.rb on lines 49..55

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

Refactorings

Further Reading

Identical code found in 1 other location

module Neo4j
  module ActiveRel
    # provides mapping of type to model name
    module Types
      extend ActiveSupport::Concern
lib/neo4j/active_node/labels.rb on lines 202..208

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

Refactorings

Further Reading

Complex class definition

require 'active_support/notifications'
require 'rails/railtie'
require 'neo4j/session_manager'
# Need the action_dispatch railtie to have action_dispatch.rescue_responses initialized correctly
require 'action_dispatch/railtie'

    Complex class definition

    require 'neo4j/class_arguments'
    
    module Neo4j::ActiveRel
      module Property
        extend ActiveSupport::Concern

      Complex class definition

      module Neo4j
        # Makes Neo4j nodes and relationships behave like ActiveRecord objects.
        # By including this module in your class it will create a mapping for the node to your ruby class
        # by using a Neo4j Label with the same name as the class. When the node is loaded from the database it
        # will check if there is a ruby class for the labels it has.

        Identical code found in 1 other location

        module Neo4j
          # Makes Neo4j Relationships more or less act like ActiveRecord objects.
          # See documentation at https://github.com/neo4jrb/neo4j/wiki/Neo4j%3A%3AActiveRel
          module ActiveRel
            extend ActiveSupport::Concern
        lib/neo4j/shared.rb on lines 44..49

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

        Refactorings

        Further Reading

        Identical code found in 1 other location

        module Neo4j
          module Shared
            # This module provides a convenient way of registering a custom Typecasting class. Custom Typecasters all follow a simple pattern.
            #
            # EXAMPLE:
        lib/neo4j/active_rel.rb on lines 47..52

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

        Refactorings

        Further Reading

        Complex class definition

        module Neo4j
          module ActiveNode
            module Query
              # rubocop:disable Metrics/ClassLength
              class QueryProxy

          Similar code found in 1 other location

          require 'set'
          module Neo4j
            # This is here to support the removed functionality of being able to
            # defined indexes and constraints on models
            # This code should be removed later
          lib/neo4j/model_schema.rb on lines 35..37

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

          Refactorings

          Further Reading

          Similar code found in 1 other location

          require 'set'
          module Neo4j
            # This is here to support the removed functionality of being able to
            # defined indexes and constraints on models
            # This code should be removed later
          lib/neo4j/model_schema.rb on lines 46..48

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

          Refactorings

          Further Reading

          Complex method in #validate_model_schema!

                def validate_model_schema!
                  ensure_model_data_state!
                  messages = {index: [], constraint: []}
                  each_schema_element do |type, model, label, property_name, exists|
                    if exists

          Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

          Refactorings

          Read More

          Complex class definition

          module Neo4j
            # Makes Neo4j Relationships more or less act like ActiveRecord objects.
            # See documentation at https://github.com/neo4jrb/neo4j/wiki/Neo4j%3A%3AActiveRel
            module ActiveRel
              extend ActiveSupport::Concern

            Complex method in #model_indexes

                  def model_indexes
                    return @model_indexes if @model_indexes
            
                    indexes = Neo4j::ActiveBase.current_session.indexes.each_with_object({}) do |row, result|
                      result[row[:label]] ||= []

            Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

            Refactorings

            Read More

            Similar code found in 1 other location

            module Neo4j
              module Shared
                module Callbacks #:nodoc:
                  extend ActiveSupport::Concern
            
            
            lib/neo4j/shared/callbacks.rb on lines 53..56

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

            Refactorings

            Further Reading

            Similar code found in 1 other location

            module Neo4j
              module Shared
                module Callbacks #:nodoc:
                  extend ActiveSupport::Concern
            
            
            lib/neo4j/shared/callbacks.rb on lines 60..63

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

            Refactorings

            Further Reading

            Complex class definition

            require 'neo4j/class_arguments'
            
            module Neo4j::ActiveRel
              module Property
                extend ActiveSupport::Concern

              Complex method in #define_has_many_id_methods

                    def define_has_many_id_methods(name)
                      define_method_unless_defined("#{name.to_s.singularize}_ids") do
                        association_proxy(name).result_ids
                      end
              
              

              Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

              Refactorings

              Read More

              Complex method in #unique_nodes_query

                      def unique_nodes_query(association, self_identifer, other_node, other_rel)
                        query.with(identity).proxy_as_optional(source_object.class, self_identifer)
                             .send(association.name, other_node, other_rel)
                             .query
                             .with(other_node)

              Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

              Refactorings

              Read More

              Complex method in #association_method_keys

                    def association_method_keys
                      @association_method_keys ||=
                        associations_keys.map(&:to_sym) +
                        associations.values.map do |association|
                          if association.type == :has_one

              Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

              Refactorings

              Read More

              Complex method in #build!

                  def build!
                    node_before_callbacks! do
                      res = query_factory(rel, rel_id, iterative_query).query.unwrapped.return(*unpersisted_return_ids).first
                      node_symbols.each { |n| wrap!(send(n), res, n) }
                      @unwrapped_rel = res.send(rel_id)

              Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

              Refactorings

              Read More

              Complex method in #scope

                    def scope(name, proc)
                      scopes[name.to_sym] = proc
              
                      klass = class << self; self; end
                      klass.instance_eval do

              Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

              Refactorings

              Read More

              Complex method in #define_has_one_getter

                    def define_has_one_getter(name)
                      define_method(name) do |node = nil, rel = nil, options = {}|
                        options, node = node, nil if node.is_a?(Hash)
              
                        # Return all results if a variable-length relationship length was given

              Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

              Refactorings

              Read More

              Complex method in #constantize_argument

                    def constantize_argument(class_argument)
                      case class_argument
                      when 'any', :any, false, nil
                        nil
                      when Array

              Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

              Refactorings

              Read More

              Similar code found in 1 other location

              module Neo4j
                module ActiveNode
                  module Query
                    # rubocop:disable Metrics/ModuleLength
                    module QueryProxyMethods
              lib/neo4j/active_node/query/query_proxy_methods.rb on lines 197..199

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

              Refactorings

              Further Reading

              Similar code found in 1 other location

              module Neo4j
                module ActiveNode
                  module Query
                    # rubocop:disable Metrics/ModuleLength
                    module QueryProxyMethods
              lib/neo4j/active_node/query/query_proxy_methods.rb on lines 211..213

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

              Refactorings

              Further Reading

              Similar code found in 1 other location

              module Neo4j::Shared
                class DeclaredProperty
                  # None of these methods interact with the database. They only keep track of property settings in models.
                  # It could (should?) handle the actual indexing/constraining, but that's TBD.
                  module Index
              lib/neo4j/shared/declared_property/index.rb on lines 23..25

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

              Refactorings

              Further Reading

              Similar code found in 1 other location

              module Neo4j::Shared
                class DeclaredProperty
                  # None of these methods interact with the database. They only keep track of property settings in models.
                  # It could (should?) handle the actual indexing/constraining, but that's TBD.
                  module Index
              lib/neo4j/shared/declared_property/index.rb on lines 18..20

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

              Refactorings

              Further Reading

              Complex method in #to_ruby

                      def to_ruby(value)
                        return value if value.is_a?(DateTime)
                        t = case value
                            when Time
                              return value.to_datetime.utc

              Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

              Refactorings

              Read More

              Complex class definition

              module Neo4j
                module Migrations
                  class Runner
                    STATUS_TABLE_FORMAT = '%-10s %-20s %s'.freeze
                    SEPARATOR = '--------------------------------------------------'.freeze

                Complex method in #wrapper

                      def wrapper(rel)
                        rel.props.symbolize_keys!
                        begin
                          most_concrete_class = class_from_type(rel.rel_type)
                          most_concrete_class.constantize.new

                Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

                Refactorings

                Read More

                Complex method in #previous_proxy_results_by_previous_id

                    def previous_proxy_results_by_previous_id(result_cache, association_name)
                      query_proxy = self.class.as(:previous).where(neo_id: result_cache.map(&:neo_id))
                      query_proxy = self.class.send(:association_query_proxy, association_name, previous_query_proxy: query_proxy, node: :next, optional: true)
                
                      Hash[*query_proxy.pluck('ID(previous)', 'collect(next)').flatten(1)].each do |_, records|

                Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

                Refactorings

                Read More

                Complex method in #attribute!

                      def attribute!(name)
                        remove_instance_variable('@attribute_methods_generated') if instance_variable_defined?('@attribute_methods_generated')
                        define_attribute_methods([name]) unless attribute_names.include?(name)
                        attributes[name.to_s] = declared_properties[name]
                        define_method("#{name}=") do |value|

                Long or complex methods can make code harder to understand. In most circumstances, methods are best as a small chunk of code (the "how") with a clear, understandable name (the "what"). Long methods can also lead to duplication, as it's harder to reuse logic that is tightly coupled to surrounding code.

                Refactorings

                Read More