cancancan-neo4j 1.2.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f5213aae2b6c9b1dced0d36464e2ae1c458f9fc9
-  data.tar.gz: dcddcb66fef4186dc1a8ac08c4e11619982d645a
+SHA256:
+  metadata.gz: 80f5ce945f4e2b8449a73be0c5d203c47899f2ce2d0332bfb9db82bff568e4c1
+  data.tar.gz: 9ac02736ba3b4ae898f67c954c45dac7059d9e4c867795699b1bc64a7036d965
 SHA512:
-  metadata.gz: '008f34d8928100cb0d40cd291f30567238007cdf3a3358766d6f2990244caf6bb76e9296ac35a5989f0a09830923c94e67d5dfb6e9f3a4e0e304cb4dcfb9c725'
-  data.tar.gz: 1a7a2ceff81a4038556862cff6281a05987286732395c4792701b53c23b2c8fb0452aa185d7d2635a8ee5d0b326077b773897108763dbccf61e6d0dc76a41571
+  metadata.gz: f1f6de129648660e99814b2e3a2869f35d62d105879bc2d2b4e75e58c9e1a4ed0db2a15a688df731c11717dbef9db1ae1ee984a3c3d6c5155b0655b13d533c46
+  data.tar.gz: 26393b95bc052363bbc607e05ad740dead1bc8fc7829dd2705bdddcd21d491ae160084489b56c6520230d77ff5a26b8932dc95b4d63a6781d4c319d5da138b96

data/cancancan-neo4j.gemspec

@@ -18,8 +18,7 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files lib init.rb cancancan-neo4j.gemspec`.split($INPUT_RECORD_SEPARATOR)
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'activemodel', '<5.2.0'
-  spec.add_dependency 'cancancan', '<=2.1.4'
+  spec.add_dependency 'cancancan'
   spec.add_dependency 'neo4j', '>= 9.0.0'
 
   spec.add_development_dependency 'bundler', '>= 1.3'

data/lib/cancancan/model_adapters/neo4j_adapter.rb

@@ -1,5 +1,6 @@
 require 'cancancan/neo4j/cypher_constructor_helper'
 require 'cancancan/neo4j/rule_cypher'
+require 'cancancan/neo4j/cypher_constructor'
 
 module CanCan
   module ModelAdapters
@@ -26,99 +27,69 @@ module CanCan
       end
 
       def self.all_conditions_match?(subject, conditions, base_class)
-        asso_conditions, model_conditions = CanCanCan::Neo4j::CypherConstructorHelper
-                                            .bifurcate_conditions(conditions)
-        associations_conditions_match?(asso_conditions, subject, base_class) &&
-          model_conditions_matches?(model_conditions, subject, base_class)
-      end
-
-      def self.model_conditions_matches?(conditions, subject, base_class)
-        return true if conditions.blank?
-        conditions = conditions.partition do |key, _|
-          base_class.associations_keys.include?(key)
-        end
-        associations_conditions, atrribute_conditions = conditions.map(&:to_h)
-        matches_attribute_conditions?(atrribute_conditions, subject) &&
-          matches_associations_relations(associations_conditions, subject)
-      end
-
-      # checks if associations exists on given node
-      def self.matches_associations_relations(conditions, subject)
-        return true if conditions.blank?
-        conditions.all? do |association, value|
-          association_exists = subject.send(association).exists?
-          value ? association_exists : !association_exists
+        return false unless subject
+        conditions.all? do |key, value|
+          if (relation = base_class.associations[key])
+            match_relation_conditions(value, subject, relation)
+          else
+            property_matches?(subject, key, value)
+          end
         end
       end
 
-      def self.matches_attribute_conditions?(conditions, subject)
-        return true if conditions.blank?
+      def self.property_matches?(subject, property, value)
         if subject.is_a?(Neo4j::ActiveNode::HasN::AssociationProxy)
-          subject.where(conditions).exists?
+          subject.where(property => value).exists?
         else
-          conditions.all? do |attribute, value|
-            subject.send(attribute) == value
-          end
+          subject.send(property) == value
         end
       end
 
-      def self.associations_conditions_match?(conditions, subject, base_class)
-        return true if conditions.blank?
-        conditions.all? do |association, conditions_hash|
-          rel_length = conditions_hash.delete(:rel_length)
-          current_subject = subject.send(association, rel_length: rel_length)
-          return false unless current_subject
-          current_model = base_class.associations[association].target_class
-          all_conditions_match?(current_subject, conditions_hash, current_model)
-        end
+      def self.match_relation_conditions(conditions, subject, association)
+        rel_length = conditions.delete(:rel_length) if conditions.is_a?(Hash)
+        subject = subject.send(association.name, rel_length: rel_length)
+        return !subject.exists? if conditions.blank?
+        return subject.exists? if conditions == true
+        all_conditions_match?(subject, conditions, association.target_class)
       end
 
       private
 
       def records_for_multiple_rules
-        base_query = base_query_proxy.query
-        cypher_options = construct_cypher_options
-        cypher_options[:matches].reject! { |mt| mt.match(var_name(@model_class)) }
-        match_string = cypher_options[:matches].uniq.join(', ')
-        base_query = base_query.match(match_string) unless match_string.blank?
-        base_query
-          .proxy_as(@model_class, var_name(@model_class))
-          .where(cypher_options[:conditions])
+        CanCanCan::Neo4j::CypherConstructor
+          .new(construct_cypher_options)
+          .query
+          .proxy_as(@model_class, var_name)
       end
 
       def construct_cypher_options
-        default_options = { conditions: '', matches: [] }
-        @rules.reverse.each_with_object(default_options) do |rule, options|
-          rule_options = { rule: rule, model_class: @model_class }
-          rule_cypher = CanCanCan::Neo4j::RuleCypher.new(rule_options)
-          CanCanCan::Neo4j::CypherConstructorHelper
-            .append_and_or_to_conditions(options, rule_cypher)
-          options[:conditions] += ('(' + rule_cypher.rule_conditions + ')')
-          options[:matches] += rule_cypher.cypher_matches
-          options
+        @rules.reverse.collect.with_index do |rule, index|
+          opts = { rule: rule, model_class: @model_class, index: index }
+          CanCanCan::Neo4j::RuleCypher.new(opts)
         end
       end
 
-      def base_query_proxy
-        @model_class.as(var_name(@model_class))
-      end
-
       def override_scope
         conditions = @rules.map(&:conditions).compact
-        return unless conditions.any? { |condition| condition.is_a?(Neo4j::ActiveNode::Query::QueryProxy) }
+        return unless conditions.any? do |condition|
+          condition.is_a?(Neo4j::ActiveNode::Query::QueryProxy)
+        end
         return conditions.first if conditions.size == 1
         raise_override_scope_error
       end
 
       def raise_override_scope_error
-        rule_found = @rules.detect { |rule| rule.conditions.is_a?(Neo4j::ActiveNode::Query::QueryProxy) }
+        rule_found = @rules.detect do |rule|
+          rule.conditions.is_a?(Neo4j::ActiveNode::Query::QueryProxy)
+        end
         raise Error,
               'Unable to merge an ActiveNode scope with other conditions. '\
-              "Instead use a hash for #{rule_found.actions.first} #{rule_found.subjects.first} ability."
+              "Instead use a hash for #{rule_found.actions.first}"\
+              " #{rule_found.subjects.first} ability."
       end
 
-      def var_name(model_class)
-        CanCanCan::Neo4j::CypherConstructorHelper.var_name(model_class)
+      def var_name
+        CanCanCan::Neo4j::CypherConstructorHelper.var_name(@model_class)
       end
     end
   end

data/lib/cancancan/neo4j.rb

@@ -1,3 +1,4 @@
+require 'active_support'
 require 'cancancan'
 require 'neo4j'
 

data/lib/cancancan/neo4j/cypher_constructor.rb

@@ -0,0 +1,83 @@
+require 'cancancan/neo4j/cypher_constructor_helper'
+
+module CanCanCan
+  module Neo4j
+    # Constructs cypher query from rule cypher options
+    class CypherConstructor
+      attr_reader :query
+
+      def initialize(rule_cyphers)
+        @model_class = rule_cyphers.first.options[:model_class]
+        reset_variables
+        construct_cypher(rule_cyphers)
+      end
+
+      def reset_variables
+        @query = @model_class.new_query
+        @current_collection = nil
+      end
+
+      def construct_cypher(rule_cyphers)
+        rule_cyphers.each do |rule_cypher|
+          rule = rule_cypher.options[:rule]
+          reset_variables if rule.conditions.blank?
+          if rule.base_behavior
+            construct_can_cypher(rule_cypher)
+          else
+            construct_cannot_cypher(rule_cypher)
+          end
+        end
+        unwind_query_with_distinct
+      end
+
+      def unwind_query_with_distinct
+        var = CanCanCan::Neo4j::CypherConstructorHelper.var_name(@model_class)
+        @query = unwind_qeury("#{var}_can")
+                 .with("DISTINCT #{var}_can as #{var}")
+      end
+
+      def unwind_qeury(var_name)
+        @query = @query.unwind("#{@current_collection} as #{var_name}")
+      end
+
+      def construct_can_cypher(rule_cypher)
+        with_clause = with_clause_for_rule(rule_cypher, true)
+        @query = @query.optional_match(rule_cypher.path)
+                       .where(rule_cypher.rule_conditions)
+                       .with(with_clause)
+      end
+
+      def with_clause_for_rule(rule_cypher, can_rule)
+        var = rule_cypher.options[:var_label]
+        with = "collect(DISTINCT #{var}) as #{var}_col"
+        if can_rule && @current_collection
+          with = "#{@current_collection} + #{with}"
+        end
+        @current_collection = "#{var}_col"
+        with
+      end
+
+      def construct_cannot_cypher(rule_cypher)
+        match_cls = match_clause(rule_cypher)
+        unwind_for_cannot(rule_cypher)
+        @query = @query.break
+                       .match(match_cls)
+                       .where_not(rule_cypher.rule_conditions)
+        with_claus = with_clause_for_rule(rule_cypher, false)
+        @query = @query.with(with_claus)
+      end
+
+      def unwind_for_cannot(rule_cypher)
+        return unless @current_collection.present?
+        var = rule_cypher.options[:var_label]
+        @query = unwind_qeury(var)
+                 .with("DISTINCT #{var} as #{var}")
+      end
+
+      def match_clause(rule_cypher)
+        var = rule_cypher.options[:var_label]
+        @current_collection.present? ? "(#{var})" : rule_cypher.path
+      end
+    end
+  end
+end

data/lib/cancancan/neo4j/cypher_constructor_helper.rb

@@ -3,72 +3,30 @@ module CanCanCan
     # Cypher query constructs
     class CypherConstructorHelper
       class << self
-        def match_node_cypher(node_class)
-          "(#{var_name(node_class)}:`#{node_class.mapped_label_name}`)"
-        end
-
-        def construct_conditions_string(conditions_hash, base_class, path = '')
-          variable_name = var_name(base_class)
-          conditions_hash.collect do |key, value|
-            condition = if base_class.associations_keys.include?(key)
-                          con = condtion_for_path(path: path,
-                                                  variable_name: variable_name,
-                                                  base_class: base_class,
-                                                  key: key)
-                          value ? con : ' NOT ' + con
-                        elsif key == :id
-                          condition_for_id(base_class, variable_name, value)
-                        else
-                          condition_for_attribute(value, variable_name, key)
-                        end
-            '(' + condition + ')'
-          end.join(' AND ')
-        end
-
-        def condition_for_attribute(value, variable_name, attribute)
-          lhs = variable_name + '.' + attribute.to_s
-          return lhs + ' IS NULL ' if value.nil?
-          rhs = value.to_s
-          rhs = "'" + rhs + "'" unless [true, false].include?(value)
-          lhs + '=' + rhs
-        end
-
-        def condtion_for_path(path:, variable_name:, base_class:, key:)
-          path = "(#{variable_name})" if path.blank?
-          relationship = base_class.associations[key]
-          path + relationship.arrow_cypher + path_end_node(relationship)
-        end
-
-        def condition_for_id(base_class, variable_name, value)
-          id_property = base_class.id_property_name
-          if id_property == :neo_id
-            "ID(#{variable_name})=#{value}"
-          else
-            variable_name + '.' + id_property.to_s + '=' + "'#{value}'"
-          end
-        end
-
         def var_name(class_constant)
           class_constant.name.downcase.split('::').join('_')
         end
 
-        def bifurcate_conditions(conditions)
-          conditions.partition { |_, value| value.is_a?(Hash) }.map(&:to_h)
+        def path_node(target_class, var_label)
+          label = target_class.mapped_label_names
+                              .map { |label_name| ":`#{label_name}`" }
+                              .join
+          "(#{var_label}#{label})"
         end
 
-        def append_and_or_to_conditions(cypher_options, rule_cypher)
-          conditions_string = cypher_options[:conditions]
-          connector = if conditions_string.blank?
-                        ''
-                      else
-                        rule_cypher.conditions_connector
-                      end
-          connector += 'NOT' if rule_cypher.append_not_to_conditions?
-          cypher_options[:conditions] = conditions_string + connector
+        def variable_in_path?(relationship, conditions)
+          boolean = [TrueClass, FalseClass].include?(conditions.class)
+          return false if conditions.blank? || boolean
+          !relationship.target_class
+                       .associations[conditions.keys.first]
+                       .present?
         end
 
-        def path_end_node(relationship)
-          '(' + relationship.target_class.mapped_label_names.map { |label_name| ":`#{label_name}`" }.join + ')'
+        def path_end_node(relationship, conditions)
+          with_var = variable_in_path?(relationship, conditions)
+          target_class = relationship.target_class
+          var_label = with_var ? var_name(target_class) : ''
+          path_node(target_class, var_label)
         end
       end
     end

data/lib/cancancan/neo4j/rule_cypher.rb

@@ -1,35 +1,34 @@
 require 'cancancan/neo4j/cypher_constructor_helper'
-require 'cancancan/neo4j/association_conditions'
 
 module CanCanCan
   module Neo4j
     # Constructs cypher conditions for rule and cypher match classes
     class RuleCypher
-      attr_reader :rule_conditions, :cypher_matches
+      attr_reader :rule_conditions, :path, :options
 
       def initialize(options)
         @options = options
-        @rule_conditions = ''
-        @cypher_matches = []
+        @rule_conditions = {}
+        initialize_path
         construct_cypher_conditions
       end
 
+      def initialize_path
+        model_class = @options[:model_class]
+        var_label = CypherConstructorHelper.var_name(model_class)
+        var_label += ('_' + (@options[:index] + 1).to_s)
+        @options[:var_label] = var_label
+        @path = CypherConstructorHelper.path_node(model_class, var_label)
+      end
+
       def construct_cypher_conditions
         if @options[:rule].conditions.blank?
           condition_for_rule_without_conditions
         else
-          set_cypher_options
+          construct_cypher_options
         end
       end
 
-      def conditions_connector
-        @options[:rule].base_behavior ? ' OR ' : ' AND '
-      end
-
-      def append_not_to_conditions?
-        !rule_conditions_blank? && !@options[:rule].base_behavior
-      end
-
       private
 
       def rule_conditions_blank?
@@ -40,23 +39,65 @@ module CanCanCan
         @rule_conditions = @options[:rule].base_behavior ? '(true)' : '(false)'
       end
 
-      def set_cypher_options
-        associations_conditions, model_conditions = CypherConstructorHelper.bifurcate_conditions(@options[:rule].conditions)
-        @rule_conditions = CypherConstructorHelper.construct_conditions_string(model_conditions, @options[:model_class], default_path) unless model_conditions.blank?
-        return if associations_conditions.blank?
-        append_association_conditions(associations_conditions)
+      def construct_cypher_options
+        @options[:rule].conditions.deep_dup.each do |key, conditions|
+          hash_cypher_options(key, conditions, @options[:model_class])
+        end
       end
 
-      def append_association_conditions(conditions_hash)
-        options = { asso_conditions: conditions_hash, parent_class: @options[:model_class], path: default_path }
-        asso_conditions_obj = AssociationConditions.new(options)
-        @rule_conditions += ' AND ' unless @rule_conditions.blank?
-        @rule_conditions += asso_conditions_obj.conditions_string
-        @cypher_matches += asso_conditions_obj.cypher_matches
+      def hash_cypher_options(key, conditions, base_class)
+        if (rel = base_class.associations[key])
+          update_path_with_rel(conditions, rel)
+          cypher_for_relation_conditions(conditions, rel)
+        else
+          merge_conditions(key, conditions, base_class)
+        end
+      end
+
+      def update_path_with_rel(conditions, rel)
+        rel_length = conditions.delete(:rel_length) if conditions
+        arrow_cypher = rel.arrow_cypher(nil, {}, false, false, rel_length)
+        node_label = CypherConstructorHelper.path_end_node(rel, conditions)
+        @path += (arrow_cypher + node_label)
       end
 
-      def default_path
-        CypherConstructorHelper.match_node_cypher(@options[:model_class])
+      def cypher_for_relation_conditions(conditions, relationship)
+        if conditions.is_a?(Hash)
+          conditions.each do |key, con|
+            hash_cypher_options(key, con, relationship.target_class)
+          end
+        else
+          update_conditions_with_path(conditions ? '' : 'NOT ')
+        end
+      end
+
+      def update_conditions_with_path(not_str)
+        @rule_conditions = not_str + @path
+        initialize_path
+      end
+
+      def merge_conditions(key, value, base_class)
+        var_name = var_label_for_conditions(base_class, key)
+        if key == :id
+          merge_condition_for_id(var_name, base_class, value)
+        else
+          (@rule_conditions[var_name] ||= {}).merge!(key => value)
+        end
+      end
+
+      def var_label_for_conditions(base_class, key)
+        condition_keys = @options[:rule].conditions.keys
+        return @options[:var_label] if condition_keys.include?(key)
+        CypherConstructorHelper.var_name(base_class)
+      end
+
+      def merge_condition_for_id(var_name, base_class, value)
+        id_property_name = base_class.id_property_name
+        if id_property_name == :neo_id
+          @rule_conditions.merge!("ID(#{var_name})" => value)
+        else
+          (@rule_conditions[var_name] ||= {}).merge!(id_property_name => value)
+        end
       end
     end
   end

data/lib/cancancan/neo4j/version.rb

@@ -2,6 +2,6 @@ module CanCanCan
 end
 module CanCanCan
   module Neo4j
-    VERSION = '1.2.2'.freeze
+    VERSION = '1.3.0'.freeze
   end
 end

metadata

@@ -1,150 +1,122 @@
 --- !ruby/object:Gem::Specification
 name: cancancan-neo4j
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.0
 platform: ruby
 authors:
 - Amit Suryavanshi
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-01 00:00:00.000000000 Z
+date: 2018-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: cancancan
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.0
-  name: activemodel
-  prerelease: false
+        version: '0'
   type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 5.2.0
-- !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: 2.1.4
-  name: cancancan
   prerelease: false
-  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<="
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.4
+        version: '0'
 - !ruby/object:Gem::Dependency
+  name: neo4j
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: 9.0.0
-  name: neo4j
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: 9.0.0
 - !ruby/object:Gem::Dependency
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.3'
-  name: bundler
-  prerelease: false
   type: :development
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.3'
-- !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  name: neo4j-community
   prerelease: false
-  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
+  name: neo4j-rake_tasks
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.0
-  name: neo4j-rake_tasks
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.0
 - !ruby/object:Gem::Dependency
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.11.3
-  name: pry
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.11.3
 - !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '10.1'
-  name: rake
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '10.1'
 - !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
-  name: rspec
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.48.1
-  name: rubocop
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -161,7 +133,7 @@ files:
 - lib/cancancan/model_adapters/neo4j_adapter.rb
 - lib/cancancan/neo4j.rb
 - lib/cancancan/neo4j/active_record_disabler.rb
-- lib/cancancan/neo4j/association_conditions.rb
+- lib/cancancan/neo4j/cypher_constructor.rb
 - lib/cancancan/neo4j/cypher_constructor_helper.rb
 - lib/cancancan/neo4j/rule_cypher.rb
 - lib/cancancan/neo4j/version.rb
@@ -169,7 +141,7 @@ homepage: https://github.com/CanCanCommunity/cancancan-neo4j
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -184,9 +156,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.6.14
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
 specification_version: 4
 summary: neo4j database adapter for CanCanCan.
 test_files: []

data/lib/cancancan/neo4j/association_conditions.rb

@@ -1,77 +0,0 @@
-require 'cancancan/neo4j/cypher_constructor_helper'
-
-module CanCanCan
-  module Neo4j
-    # Constructs cypher conditions for associations conditions hash
-    class AssociationConditions
-      attr_reader :conditions_string, :cypher_matches
-
-      def initialize(options)
-        @options = options
-        @conditions_string = ''
-        @cypher_matches = []
-        construct_conditions
-      end
-
-      def construct_conditions
-        @options[:asso_conditions].each do |association, conditions|
-          relationship = association_relation(association)
-          associations_conditions, model_conditions = CypherConstructorHelper.bifurcate_conditions(conditions)
-          rel_length = associations_conditions.delete(:rel_length)
-          current_path = append_path_to_conditions(relationship, model_conditions, rel_length)
-          append_model_conditions(model_conditions, relationship, current_path)
-          append_association_conditions(associations_conditions, relationship, rel_length)
-        end
-      end
-
-      def association_relation(association)
-        @options[:parent_class].associations[association]
-      end
-
-      def append_association_conditions(conditions, relationship, rel_length)
-        return if conditions.blank?
-        asso_conditions_obj = AssociationConditions.new(asso_conditions: conditions, parent_class: relationship.target_class, path: path_with_relationship(relationship, rel_length))
-        append_and_to_conditions_string
-        @conditions_string += asso_conditions_obj.conditions_string
-        @cypher_matches += asso_conditions_obj.cypher_matches
-      end
-
-      def append_path_to_conditions(relationship, model_conditions, rel_length)
-        target_class = relationship.target_class
-        model_attr_exists = model_conditions.any? do |key, _|
-          !target_class.associations_keys.include?(key)
-        end
-        to_node = CypherConstructorHelper.match_node_cypher(target_class) if model_attr_exists
-        current_path = path_with_relationship(relationship, rel_length, to_node)
-        if model_attr_exists
-          append_matches(relationship)
-          append_and_to_conditions_string
-          @conditions_string += current_path
-        end
-        current_path
-      end
-
-      def append_matches(relationship)
-        node_class = relationship.target_class
-        @cypher_matches << CypherConstructorHelper.match_node_cypher(node_class)
-      end
-
-      def append_and_to_conditions_string
-        @conditions_string += ' AND ' unless @conditions_string.blank?
-      end
-
-      def append_model_conditions(model_conditions, relationship, current_path)
-        return if model_conditions.blank?
-        con_string = CypherConstructorHelper.construct_conditions_string(model_conditions, relationship.target_class, current_path)
-        append_and_to_conditions_string
-        @conditions_string += con_string
-      end
-
-      def path_with_relationship(relationship, rel_length, to_node = nil)
-        arrow_cypher = relationship.arrow_cypher(nil, {}, false, false, rel_length)
-        to_node_label = CypherConstructorHelper.path_end_node(relationship)
-        @options[:path] + arrow_cypher + (to_node || to_node_label)
-      end
-    end
-  end
-end