boltless 1.0.0

data/lib/boltless/extensions/operations.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Boltless
+  module Extensions
+    # A top-level gem-module extension for neo4j operations.
+    #
+    # rubocop:disable Metrics/BlockLength because this is how
+    #   an +ActiveSupport::Concern+ looks like
+    module Operations
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Clear everything from the neo4j database, including indexes,
+        # constraints, all nodes and all relationships. Afterwards the
+        # database is completely empty and "unconfigured". (dist clean)
+        #
+        # @param database [String, Symbol] the neo4j database to use
+        #
+        # rubocop:disable Metrics/MethodLength because of
+        #   multiple transactions
+        # rubocop:disable Metrics/AbcSize because of the extra transaction
+        #   handlings (we cannot do multiple structural changes in a single
+        #   transaction)
+        def clear_database!(database: Boltless.configuration.default_db)
+          logger.warn('Clear neo4j database ..')
+
+          # Clear all constraints, this is a schema
+          # modification so we have to run it in a separate transaction
+          transaction!(database: database) do |tx|
+            constraint_names.each do |name|
+              logger.info(" > Drop neo4j constraint #{name} ..")
+              tx.run!("DROP CONSTRAINT #{name}")
+            end
+          end
+
+          # Clear all indexes, this is a schema
+          # modification so we have to run it in a separate transaction
+          transaction!(database: database) do |tx|
+            index_names.each do |name|
+              logger.info(" > Drop neo4j index #{name} ..")
+              tx.run!("DROP INDEX #{name}")
+            end
+          end
+
+          # Afterwards clear all nodes and relationships
+          stats = write!('MATCH (n) DETACH DELETE n',
+                         database: database,
+                         with_stats: true).stats
+
+          logger.info(" > Nodes deleted: #{stats[:nodes_deleted]}")
+          logger.info(
+            " > Relationships deleted: #{stats[:relationship_deleted]}"
+          )
+        end
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/AbcSize
+
+        # Check whenever the given name is already taken on the neo4j
+        # database for a component (index or constraint).
+        #
+        # @param database [String, Symbol] the neo4j database to use
+        # @param name [String, Symbol] the name to check
+        # @return [Boolean] whenever the name is taken/present or not
+        def component_name_present?(name,
+                                    database: Boltless.configuration.default_db)
+          pool = index_names(database: database) +
+                 constraint_names(database: database)
+          pool.include? name.to_s
+        end
+
+        # List all currently available indexes by their names.
+        #
+        # @param database [String, Symbol] the neo4j database to use
+        # @return [Array<String>] the index names
+        def index_names(database: Boltless.configuration.default_db)
+          res = query!('SHOW INDEXES YIELD name',
+                       database: database).pluck(:name)
+          res - constraint_names
+        end
+
+        # List all currently available constraints by their names.
+        #
+        # @param database [String, Symbol] the neo4j database to use
+        # @return [Array<String>] the constraint names
+        def constraint_names(database: Boltless.configuration.default_db)
+          query!('SHOW CONSTRAINTS YIELD name',
+                 database: database).pluck(:name)
+        end
+
+        # Create a new index at the neo4j database.
+        #
+        # @see https://bit.ly/3GawzVP
+        # @param name [String, Symbol] the name of the index, we do not
+        #   allow autogenerated names
+        # @param type [String, Symbol] the index type (+:btree+, +:lookup+,
+        #   +:text+, +:range+, +:point+, +:fulltext+)
+        # @param options [Hash{Symbol => Mixed}] additional index options
+        #   for neo4j
+        # @param for [String] the node/property query for matching
+        # @param on [String] the collection of nodes/properties to index
+        # @param database [String, Symbol] the neo4j database to use
+        #
+        # rubocop:disable Metrics/ParameterLists because of the various
+        #   configuration options of a neo4j index
+        def add_index(name:, for:, on:, type: :btree, options: nil,
+                      database: Boltless.configuration.default_db)
+          # CREATE TEXT INDEX [index_name] IF NOT EXISTS
+          # FOR ()-[r:TYPE_NAME]-()
+          # ON (r.propertyName)
+          # OPTIONS {option: value[, ...]}
+
+          # Assemble and perform the neo4j query
+          type = type == :btree ? '' : type.to_s.upcase
+          options = options.blank? ? '' : "OPTIONS #{to_options(options)}"
+          write <<~CYPHER, database: database
+            CREATE #{type} INDEX #{name} IF NOT EXISTS
+            FOR #{binding.local_variable_get(:for)}
+            ON #{on}
+            #{options}
+          CYPHER
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        # Drop an index from the neo4j database.
+        #
+        # @param name [String, Symbol] the name of the index
+        # @param database [String, Symbol] the neo4j database to use
+        def drop_index(name, database: Boltless.configuration.default_db)
+          write!("DROP INDEX #{name} IF EXISTS", database: database)
+        end
+
+        # Create a new constraint at the neo4j database.
+        #
+        # Adding constraints is an atomic operation that can take a while.
+        # All existing data has to be scanned before neo4j can turn the
+        # constraint 'on'.
+        #
+        # @see https://bit.ly/3GawzVP
+        #
+        # @param name [String, Symbol] the name of the index, we do not
+        #   allow autogenerated names
+        # @param options [Hash{Symbol => Mixed}] additional index options
+        #   for neo4j
+        # @param for [String] the node/property query for matching
+        # @param require [String] the constraint to apply
+        # @param database [String, Symbol] the neo4j database to use
+        def add_constraint(name:, for:, require:, options: nil,
+                           database: Boltless.configuration.default_db)
+          # CREATE CONSTRAINT [constraint_name] IF NOT EXISTS
+          # FOR (n:LabelName)
+          # REQUIRE n.propertyName IS UNIQUE
+          # OPTIONS { option: value[, ...] }
+
+          # Assemble and perform the neo4j query
+          options = options.blank? ? '' : "OPTIONS #{to_options(options)}"
+          write! <<~CYPHER, database: database
+            CREATE CONSTRAINT #{name} IF NOT EXISTS
+            FOR #{binding.local_variable_get(:for)}
+            REQUIRE #{binding.local_variable_get(:require)}
+            #{options}
+          CYPHER
+        end
+
+        # Drop a constraint from the neo4j database.
+        #
+        # @param name [String, Symbol] the name of the constraint
+        # @param database [String, Symbol] the neo4j database to use
+        def drop_constraint(name, database: Boltless.configuration.default_db)
+          write!("DROP CONSTRAINT #{name} IF EXISTS", database: database)
+        end
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/boltless/extensions/transactions.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+module Boltless
+  module Extensions
+    # A top-level gem-module extension to add easy-to-use methods to use the
+    # Cypher transactional API.
+    #
+    # rubocop:disable Metrics/BlockLength because this is how
+    #   an +ActiveSupport::Concern+ looks like
+    # rubocop:disable Metrics/ModuleLength dito
+    module Transactions
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Perform a single Cypher statement and return its results.
+        #
+        # @param cypher [String] the Cypher statement to run
+        # @param access_mode [String, Symbol] the neo4j transaction access
+        #   mode, use +:read+ or +:write+
+        # @param database [String, Symbol] the neo4j database to use
+        # @param raw_results [Boolean] whenever to return the plain HTTP API
+        #   JSON results (as plain +Hash{Symbol => Mixed}/Array+ data), or not
+        #   (then we return +Array<Boltless::Result>+ structs
+        # @return [Array<Hash{Symbol => Mixed}>] the (raw) neo4j results
+        #
+        # @raise [Boltless::Errors::RequestError] in case of low-level issues
+        # @raise [Boltless::Errors::ResponseError] in case of issues
+        #   found by neo4j
+        def execute!(cypher, access_mode: :write,
+                     database: Boltless.configuration.default_db,
+                     raw_results: false, **args)
+          one_shot!(
+            access_mode,
+            database: database,
+            raw_results: raw_results
+          ) do |tx|
+            tx.add(cypher, **args)
+          end.first
+        end
+        alias_method :write!, :execute!
+
+        # Perform a single Cypher statement and return its results.
+        # Any transfer error will be rescued.
+        #
+        # @param cypher [String] the Cypher statement to run
+        # @param access_mode [String, Symbol] the neo4j transaction access
+        #   mode, use +:read+ or +:write+
+        # @param database [String, Symbol] the neo4j database to use
+        # @param raw_results [Boolean] whenever to return the plain HTTP API
+        #   JSON results (as plain +Hash{Symbol => Mixed}/Array+ data), or not
+        #   (then we return +Array<Boltless::Result>+ structs
+        # @return [Array<Hash{Symbol => Mixed}>, nil] the (raw) neo4j
+        #   results, or +nil+ in case of errors
+        def execute(cypher, access_mode: :write,
+                    database: Boltless.configuration.default_db,
+                    raw_results: false, **args)
+          one_shot(
+            access_mode,
+            database: database,
+            raw_results: raw_results
+          ) do |tx|
+            tx.add(cypher, **args)
+          end&.first
+        end
+        alias_method :write, :execute
+
+        # A simple shortcut to perform a single Cypher in read access mode. See
+        # +.execute!+ for further details.
+        #
+        # @param cypher [String] the Cypher statement to run
+        # @param access_mode [String, Symbol] the neo4j transaction access
+        #   mode, use +:read+ or +:write+
+        # @param args [Hash{Symbol}] all additional arguments of +.execute!+
+        # @return [Array<Hash{Symbol => Mixed}>, nil] the (raw) neo4j
+        #   results, or +nil+ in case of errors
+        def query!(cypher, access_mode: :read, **args)
+          execute!(cypher, access_mode: access_mode, **args)
+        end
+        alias_method :read!, :query!
+
+        # A simple shortcut to perform a single Cypher in read access mode. See
+        # +.execute+ for further details. Any transfer error will be rescued.
+        #
+        # @param cypher [String] the Cypher statement to run
+        # @param access_mode [String, Symbol] the neo4j transaction access
+        #   mode, use +:read+ or +:write+
+        # @param args [Hash{Symbol}] all additional arguments of +.execute+
+        # @return [Array<Hash{Symbol => Mixed}>, nil] the (raw) neo4j
+        #   results, or +nil+ in case of errors
+        def query(cypher, access_mode: :read, **args)
+          execute(cypher, access_mode: access_mode, **args)
+        end
+        alias_method :read, :query
+
+        # Start an single shot transaction and run all the given Cypher
+        # statements inside it. When anything within the user given block
+        # raises, we do not send the actual HTTP API request to the neo4j
+        # server.
+        #
+        # @param access_mode [String, Symbol] the neo4j transaction access
+        #   mode, use +:read+ or +:write+
+        # @param database [String, Symbol] the neo4j database to use
+        # @param raw_results [Boolean] whenever to return the plain HTTP API
+        #   JSON results (as plain +Hash{Symbol => Mixed}/Array+ data), or not
+        #   (then we return +Array<Boltless::Result>+ structs
+        # @yield [Boltless::StatementCollector] the statement collector object
+        #   to use
+        # @return [Array<Hash{Symbol => Mixed}>] the (raw) neo4j results
+        #
+        # @raise [Boltless::Errors::RequestError] in case of low-level issues
+        # @raise [Boltless::Errors::ResponseError] in case of issues
+        #   found by neo4j
+        # @raise [Mixed] when an exception occurs inside the user given block
+        def one_shot!(access_mode = :write,
+                      database: Boltless.configuration.default_db,
+                      raw_results: false)
+          # Fetch a connection from the pool
+          connection_pool.with do |connection|
+            # Setup a neo4j HTTP API request abstraction instance,
+            # and a statement collector
+            req = Request.new(connection, access_mode: access_mode,
+                                          database: database,
+                                          raw_results: raw_results)
+            collector = StatementCollector.new
+
+            # Run the user given block, and pass down the collector
+            yield(collector)
+
+            # Perform the actual HTTP API request
+            req.one_shot_transaction(*collector.statements)
+          end
+        end
+
+        # Start an single shot transaction and run all the given Cypher
+        # statements inside it. When anything within the user given block
+        # raises, we do not send the actual HTTP API request to the neo4j
+        # server. Any other transfer error will be rescued.
+        #
+        # @param access_mode [String, Symbol] the neo4j transaction access
+        #   mode, use +:read+ or +:write+
+        # @param database [String, Symbol] the neo4j database to use
+        # @param raw_results [Boolean] whenever to return the plain HTTP API
+        #   JSON results (as plain +Hash{Symbol => Mixed}/Array+ data), or not
+        #   (then we return +Array<Boltless::Result>+ structs
+        # @yield [Boltless::StatementCollector] the statement collector object
+        #   to use
+        # @return [Array<Hash{Symbol => Mixed}>, nil] the (raw) neo4j results,
+        #   or +nil+ on errors
+        #
+        # @raise [Mixed] when an exception occurs inside the user given block
+        #
+        # rubocop:disable Metrics/MethodLength because of the extra
+        #   error handling
+        def one_shot(access_mode = :write,
+                     database: Boltless.configuration.default_db,
+                     raw_results: false)
+          # Fetch a connection from the pool
+          connection_pool.with do |connection|
+            # Setup a neo4j HTTP API request abstraction instance,
+            # and a statement collector
+            req = Request.new(connection, access_mode: access_mode,
+                                          database: database,
+                                          raw_results: raw_results)
+            collector = StatementCollector.new
+
+            # Run the user given block, and pass down the collector
+            yield(collector)
+
+            # Perform the actual HTTP API request
+            begin
+              req.one_shot_transaction(*collector.statements)
+            rescue Errors::RequestError, Errors::ResponseError
+              # When we hit an error here, we will return +nil+ to signalize it
+              nil
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # Start an new transaction and run Cypher statements inside it. When
+        # anything within the user given block raises, we automatically
+        # rollback the transaction.
+        #
+        # @param access_mode [String, Symbol] the neo4j transaction access
+        #   mode, use +:read+ or +:write+
+        # @param database [String, Symbol] the neo4j database to use
+        # @param raw_results [Boolean] whenever to return the plain HTTP API
+        #   JSON results (as plain +Hash{Symbol => Mixed}/Array+ data), or not
+        #   (then we return +Array<Boltless::Result>+ structs
+        # @yield [Boltless::Transaction] the transaction object to use
+        # @return [Mixed] the result of the user given block
+        #
+        # @raise [Boltless::Errors::RequestError] in case of low-level issues
+        # @raise [Boltless::Errors::ResponseError] in case of issues
+        #   found by neo4j
+        # @raise [Mixed] when an exception occurs inside the user given
+        #   block, we re-raise it
+        #
+        # rubocop:disable Metrics/MethodLength because this is the workflow
+        def transaction!(access_mode = :write,
+                         database: Boltless.configuration.default_db,
+                         raw_results: false)
+          # Fetch a connection from the pool
+          connection_pool.with do |connection|
+            # Setup and start a new transaction
+            tx = Boltless::Transaction.new(connection,
+                                           database: database,
+                                           access_mode: access_mode,
+                                           raw_results: raw_results)
+            tx.begin!
+
+            begin
+              # Run the user given block, and pass
+              # the transaction instance down
+              res = yield(tx)
+            rescue StandardError => e
+              # In case anything raises inside the user block,
+              # we try to auto-rollback the opened transaction
+              tx.rollback
+
+              # Re-raise the original error
+              raise e
+            end
+
+            # Try to commit after the user given block,
+            # when the transaction is still open
+            tx.commit! if tx.state.open?
+
+            # Return the result of the user given block
+            res
+          ensure
+            # Clean up the transaction object
+            tx.cleanup
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # Start an new transaction and run Cypher statements inside it. When
+        # anything within the user given block raises, we automatically
+        # rollback the transaction.
+        #
+        # @param access_mode [String, Symbol] the neo4j transaction access
+        #   mode, use +:read+ or +:write+
+        # @param database [String, Symbol] the neo4j database to use
+        # @param raw_results [Boolean] whenever to return the plain HTTP API
+        #   JSON results (as plain +Hash{Symbol => Mixed}/Array+ data), or not
+        #   (then we return +Array<Boltless::Result>+ structs
+        # @yield [Boltless::Transaction] the transaction object to use
+        # @return [Mixed] the result of the user given block
+        #
+        # @raise [Mixed] when an exception occurs inside the user given
+        #   block, we re-raise it
+        #
+        # rubocop:disable Metrics/MethodLength because this is the workflow
+        def transaction(access_mode = :write,
+                        database: Boltless.configuration.default_db,
+                        raw_results: false)
+          # Fetch a connection from the pool
+          connection_pool.with do |connection|
+            # Setup and start a new transaction, when the start up fails,
+            # we return +nil+ and stop further processing
+            tx = Boltless::Transaction.new(connection,
+                                           database: database,
+                                           access_mode: access_mode,
+                                           raw_results: raw_results)
+            next unless tx.begin
+
+            begin
+              # Run the user given block, and pass
+              # the transaction instance down
+              res = yield(tx)
+            rescue StandardError => e
+              # In case anything raises inside the user block,
+              # we auto-rollback the opened transaction
+              tx.rollback
+
+              # Re-raise the original error
+              raise e
+            end
+
+            # Try to commit after the user given block, when the transaction is
+            # still open, and return the results of the user given block if the
+            # transaction is successfully commited
+            tx_committed = tx.state.open? ? tx.commit : true
+            next res if tx_committed
+
+            # Otherwise return +nil+ again,
+            # to signalize the transaction failed
+            nil
+          ensure
+            # Clean up the transaction object
+            tx.cleanup
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+    # rubocop:enable Metrics/ModuleLength
+  end
+end

data/lib/boltless/extensions/utilities.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Boltless
+  module Extensions
+    # A top-level gem-module extension add helpers and utilites.
+    #
+    # rubocop:disable Metrics/BlockLength because this is how
+    #   an +ActiveSupport::Concern+ looks like
+    module Utilities
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Build an Cypher query string with unsafe user inputs. The inputs
+        # will be replaced with their escaped/prepared equivalents. This is
+        # handy in cases where user inputs cannot be passed as Cypher
+        # parameters (eg.  +$subject+) like node labels or relationship
+        # types.
+        #
+        # Replacements must be referenced like this: +%<subject_label>s+ in
+        # the Cypher string template.
+        #
+        # We support various replacement/preparation strategies. Name the
+        # replacement keys like this:
+        #
+        #   * +*_label(s?)+ will cast to string, camelize it and
+        #     escapes if needed
+        #   * +*_type(s?)+ will cast to string, underscore+upcase it and
+        #     escapes if needed
+        #   * +*_str(s?)+ will cast to string and escapes with double quotes
+        #
+        # All the replacements also work with multiple values (sets/arrays).
+        # The correct concatenation is guaranteed.
+        #
+        # @see https://bit.ly/3atOivN neo4j Cypher expressions
+        # @see https://bit.ly/3RktlEa +WHERE properties(d) = $props+
+        # @param replacements [Hash{Symbol,String => Mixed}] the
+        #   inline-replacements
+        # @yield the given block result will be used as Cypher string
+        #   template
+        # @return [String] the built Cypher query
+        #
+        # rubocop:disable Metrics/MethodLength because of the various
+        #   replacement strategies
+        # rubocop:disable Metrics/AbcSize dito
+        def build_cypher(**replacements)
+          # Process the given replacements in order to prevent Cypher
+          # injections from user given values
+          replacements = replacements \
+                         .stringify_keys
+                         .each_with_object({}) do |(key, val), memo|
+            val = prepare_label(val) if key.match?(/_labels?$|^labels?$/)
+            val = prepare_type(val) if key.match?(/_types?$|^types?$/)
+            val = prepare_string(val) if key.match?(/_strs?$/)
+            memo[key.to_sym] = val
+          end
+
+          # Then evaluate the given block to get the Cypher template
+          # which should be interpolated with the replacements
+          format(yield.to_s, replacements).lines.map do |line|
+            line.split('//').first.rstrip.yield_self do |processed|
+              processed.empty? ? nil : processed
+            end
+          end.compact.join("\n")
+        end
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/AbcSize
+
+        # Prepare the given input(s) as node label for injection-free Cypher.
+        #
+        # @param inputs [Array<#to_s>] the input object(s) to prepare as label
+        # @return [String] the prepared and concatenated string
+        # @raise [ArgumentError] when no inputs are given, or only +nil+
+        def prepare_label(*inputs)
+          list = inputs.map { |itm| Array(itm) }.flatten.compact
+          raise ArgumentError, "Bad labels: #{inputs.inspect}" if list.empty?
+
+          list.map do |input|
+            res = input.to_s.underscore.gsub(/-/, '_').camelcase
+            res.match?(/[^a-z0-9]/i) ? "`#{res}`" : res
+          end.sort.uniq.join(':')
+        end
+
+        # Prepare the given input as relationship tyep for
+        # injection-free Cypher.
+        #
+        # @param inputs [Array<#to_s>] the input object(s) to prepare as type
+        # @return [String] the prepared string
+        # @raise [ArgumentError] when no inputs are given, or only +nil+
+        def prepare_type(*inputs)
+          list = inputs.map { |itm| Array(itm) }.flatten.compact
+          raise ArgumentError, "Bad types: #{inputs.inspect}" if list.empty?
+
+          list.map do |input|
+            res = input.to_s.underscore.gsub(/-/, '_').upcase
+            res.match?(/[^a-z0-9_]/i) ? "`#{res}`" : res
+          end.sort.uniq.join('|')
+        end
+
+        # Prepare the given input as escaped string for injection-free Cypher.
+        #
+        # @param inputs [Array<#to_s>] the input object(s) to prepare
+        #   as string
+        # @return [String] the prepared string
+        def prepare_string(*inputs)
+          inputs = inputs.map { |itm| Array(itm) }.flatten.compact
+          return %("") if inputs.empty?
+
+          inputs.map do |input|
+            "\"#{input.to_s.gsub(/"/, '\"')}\""
+          end.uniq.join(', ')
+        end
+
+        # Generate a neo4j specific options data format from the given object.
+        #
+        # @param obj [Mixed] the object to convert accordingly
+        # @return [String] the string representation for neo4j
+        def to_options(obj)
+          # We keep nil, as it is
+          return if obj.nil?
+
+          # We have to escape all string input values with single quotes
+          return %('#{obj}') if obj.is_a? String
+
+          # We have to walk through array values and assemble
+          # a resulting string
+          if obj.is_a? Array
+            list = obj.map { |elem| to_options(elem) }.compact
+            return %([ #{list.join(', ')} ])
+          end
+
+          # We keep non-hash values (eg. boolean, integer, etc) as they are
+          # and use their Ruby string representation accordingly
+          return obj.to_s unless obj.is_a? Hash
+
+          # Hashes require specialized key quotation with backticks
+          res = obj.map { |key, value| %(`#{key}`: #{to_options(value)}) }
+          %({ #{res.join(', ')} })
+        end
+
+        # Resolve the given Cypher statement with all parameters
+        # for debugging.
+        #
+        # @param cypher [String] the Cypher query to perform
+        # @param args [Hash{Symbol => Mixed}] additional Cypher variables
+        # @return [String] the resolved Cypher statement
+        def resolve_cypher(cypher, **args)
+          args.reduce(cypher) do |str, (var, val)|
+            str.gsub(/\$#{var}\b/) do
+              val.is_a?(String) ? %("#{val}") : val.to_s
+            end
+          end
+        end
+
+        # Get the logging color for the given Cypher statement in order to
+        # visually distinguish the queries on the log.
+        #
+        # @param cypher [String] the Cypher query to check
+        # @return [Symbol] the ANSI color name
+        #
+        # rubocop:disable Metrics/CyclomaticComplexity because of the
+        #   various conditions
+        def cypher_logging_color(cypher)
+          cypher = cypher.to_s.downcase.lines.map(&:strip)
+
+          # Check for transaction starts
+          return :magenta if cypher.first == 'begin'
+
+          # Check for creations/transaction commits
+          return :green \
+            if cypher.first == 'commit' || cypher.grep(/\s*create /).any?
+
+          # Check for upserts/updates
+          return :yellow if cypher.grep(/\s*(set|merge) /).any?
+
+          # Check for deletions
+          return :red if cypher.first == 'rollback' \
+            || cypher.grep(/\s*(delete|remove) /).any?
+
+          # Everything else, like matches
+          :light_blue
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end