cancancan-activegraph 3.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2defa43a68a1eb9ba340c8f401adca57a16ec00cc83aca4ef2238882ad9c7f0b
+  data.tar.gz: dd705d3a13fd06a80819d758a3d90637107c9350a92e37024b7d836be3e293bc
+SHA512:
+  metadata.gz: 9616dbf01e6919e222f711d73bfc4e7c1980a786acf81ad89dfa55a632206e10f021065e3b0b09d7d10f8f6068b7c6a54087bac86df54f6a555f05df97651dd4
+  data.tar.gz: ee6ae0f511911eb92e33a08f274e7d6a9af404d4a4ee1f6392b7c029e039966d5c1aaac503320c925aa93a727cae5c9b2542b4a4d9b2a4bab34fa88a1381c6e2

data/cancancan-activegraph.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cancancan/active_graph/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cancancan-activegraph'
+  spec.version       = CanCanCan::ActiveGraph::VERSION
+  spec.authors       = ['Amit Suryavanshi']
+  spec.email         = ['amitbsuryavanshi@gmail.com']
+  spec.homepage      = 'https://github.com/CanCanCommunity/cancancan-activegraph'
+  spec.summary       = 'neo4j database adapter for CanCanCan.'
+  spec.description   = "Implements CanCanCan's rule-based record fetching using neo4j gem."
+  spec.platform      = Gem::Platform::RUBY
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files lib init.rb cancancan-activegraph.gemspec`.split($INPUT_RECORD_SEPARATOR)
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activegraph', '>= 9.0.0'
+  spec.add_dependency 'cancancan'
+  
+  spec.add_development_dependency 'bundler', '>= 1.3'
+  spec.add_development_dependency("neo4j-#{RUBY_PLATFORM =~ /java/ ? 'java' : 'ruby'}-driver", '>= 0.3.0')
+  spec.add_development_dependency('neo4j-rake_tasks', '>= 0.3.0')
+  spec.add_development_dependency 'pry', '>= 0.11.3'
+  spec.add_development_dependency 'rake', '>= 10.1'
+  spec.add_development_dependency 'rspec', '>= 3.2'
+  spec.add_development_dependency 'rubocop', '>= 0.48.1'
+end

data/lib/cancancan/active_graph/active_record_disabler.rb

@@ -0,0 +1,7 @@
+class CanCanCan::Sequel::ActiveRecordDisabler
+  ::CanCan::ModelAdapters::ActiveRecord4Adapter.class_eval do
+    def self.for_class?(_)
+      false
+    end
+  end
+end

data/lib/cancancan/active_graph/cypher_constructor.rb

@@ -0,0 +1,92 @@
+require 'cancancan/active_graph/cypher_constructor_helper'
+
+module CanCanCan
+  module ActiveGraph
+    # Constructs cypher query from rule cypher options
+    class CypherConstructor
+      attr_reader :query, :scope
+
+      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|
+          construct_cypher_for_rule(rule_cypher)
+        end
+        unwind_query_with_distinct
+      end
+
+      def construct_cypher_for_rule(rule_cypher)
+        rule = rule_cypher.options[:rule]
+        return if update_scope(rule_cypher)
+        reset_variables if rule.conditions.blank?
+        if rule.base_behavior
+          construct_can_cypher(rule_cypher)
+        else
+          construct_cannot_cypher(rule_cypher)
+        end
+      end
+
+      def update_scope(rule_cypher)
+        @scope = rule_cypher.options[:scope]
+      end
+
+      def unwind_query_with_distinct
+        var = CanCanCan::ActiveGraph::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/active_graph/cypher_constructor_helper.rb

@@ -0,0 +1,33 @@
+module CanCanCan
+  module ActiveGraph
+    # Cypher query constructs
+    class CypherConstructorHelper
+      class << self
+        def var_name(class_constant)
+          class_constant.name.downcase.split('::').join('_')
+        end
+
+        def path_node(target_class, var_label)
+          label = target_class.mapped_label_names
+                              .map { |label_name| ":`#{label_name}`" }
+                              .join
+          "(#{var_label}#{label})"
+        end
+
+        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_var(relationship, conditions)
+          with_var = variable_in_path?(relationship, conditions)
+          target_class = relationship.target_class
+          with_var ? var_name(target_class) : ''
+        end
+      end
+    end
+  end
+end

data/lib/cancancan/active_graph/rule_cypher.rb

@@ -0,0 +1,119 @@
+require 'cancancan/active_graph/cypher_constructor_helper'
+
+module CanCanCan
+  module ActiveGraph
+    # Constructs cypher conditions for rule and cypher match classes
+    class RuleCypher
+      attr_reader :rule_conditions, :path, :options
+
+      def initialize(options)
+        @options = options
+        @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 += index_sub_str
+        @options[:var_label] = var_label
+        @path = CypherConstructorHelper.path_node(model_class, var_label)
+      end
+
+      def construct_cypher_conditions
+        conditions = @options[:rule].conditions
+        if conditions.is_a?(::ActiveGraph::Node::Query::QueryProxy)
+          return @options[:scope] = conditions
+        end
+        if conditions.blank?
+          condition_for_rule_without_conditions
+        else
+          construct_cypher_options
+        end
+      end
+
+      private
+
+      def index_sub_str
+        index = @options[:index]
+        return '' unless index
+        ('_' + (index + 1).to_s)
+      end
+
+      def rule_conditions_blank?
+        @options[:rule].conditions.blank?
+      end
+
+      def condition_for_rule_without_conditions
+        @rule_conditions = @options[:rule].base_behavior ? '' : '(false)'
+      end
+
+      def construct_cypher_options
+        @options[:rule].conditions.deep_dup.each do |key, conditions|
+          hash_cypher_options(key, conditions, @options[:model_class])
+        end
+      end
+
+      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 = path_end_node(rel, conditions)
+        @path += (arrow_cypher + node_label)
+      end
+
+      def path_end_node(rel, conditions)
+        label = CypherConstructorHelper.path_end_var(rel, conditions)
+        label += '_01' if !label.blank? && @path.include?("#{label}:")
+        @options[:con_var_label] = label
+        CypherConstructorHelper.path_node(rel.target_class, label)
+      end
+
+      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
+        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
+        @options[:con_var_label] || @options[:var_label]
+      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
+end

data/lib/cancancan/active_graph/single_rule_cypher.rb

@@ -0,0 +1,46 @@
+require 'cancancan/active_graph/cypher_constructor_helper'
+
+module CanCanCan
+  module ActiveGraph
+    # Return records for single cancan rule
+    class SingleRuleCypher
+      attr_reader :rule, :model_class
+      def initialize(rule, model_class)
+        @rule = rule
+        @model_class = model_class
+      end
+
+      def records
+        conds = rule.conditions
+        return conds if conds.is_a?(::ActiveGraph::Node::Query::QueryProxy) || conds.is_a?(::ActiveGraph::Node::HasN::AssociationProxy)
+        return records_for_no_conditions if conds.blank?
+        records_for_hash_conditions
+      end
+
+      private
+
+      def records_for_no_conditions
+        if rule.base_behavior
+          model_class.all
+        else
+          model_class.where('false')
+        end
+      end
+
+      def records_for_hash_conditions
+        cypher = CanCanCan::ActiveGraph::RuleCypher.new(rule: rule,
+                                                  model_class: model_class,
+                                                  index: nil)
+        model_class.new_query
+                   .match(cypher.path)
+                   .where(cypher.rule_conditions)
+                   .proxy_as(model_class, var_lable)
+                   .distinct
+      end
+
+      def var_lable
+        CypherConstructorHelper.var_name(model_class)
+      end
+    end
+  end
+end

data/lib/cancancan/active_graph/version.rb

@@ -0,0 +1,7 @@
+module CanCanCan
+end
+module CanCanCan
+  module ActiveGraph
+    VERSION = '3.0.1'.freeze
+  end
+end

data/lib/cancancan/activegraph.rb

@@ -0,0 +1,9 @@
+require 'active_support'
+require 'cancancan'
+require 'active_graph'
+
+require 'cancancan/active_graph/version'
+require 'cancancan/model_adapters/active_graph_adapter'
+require 'cancancan/active_graph/cypher_constructor_helper'
+require 'cancancan/extensions/ability'
+require 'cancancan/extensions/conditions_matcher'

data/lib/cancancan/extensions/ability.rb

@@ -0,0 +1,24 @@
+module CanCanCan
+  module Extensions
+    # orverwriting .relevant_rules_for_match method from CanCan::Ability module
+    module Ability
+      # original method, to want to make scope work with rule like
+      # "can :read, Article, Article.where(secret: true)",
+      # we are skipping raising of error in case of rule being raw query
+      # def relevant_rules_for_match(action, subject)
+      #   relevant_rules(action, subject).each do |rule|
+      #     next unless rule.only_raw_sql?
+      #     raise Error,
+      #           "The can? and cannot? call cannot be used with a raw sql."
+      #   end
+      # end
+      def relevant_rules_for_match(action, subject)
+        relevant_rules(action, subject)
+      end
+    end
+  end
+end
+
+CanCan::Ability.module_eval do
+  include CanCanCan::Extensions::Ability
+end

data/lib/cancancan/extensions/conditions_matcher.rb

@@ -0,0 +1,19 @@
+CanCan::ConditionsMatcher.module_eval do
+  private
+
+  def matches_non_block_conditions(subject)
+    if @conditions.is_a?(Hash)
+      return nested_subject_matches_conditions?(subject) if subject.class == Hash
+      return matches_conditions_hash?(subject) unless subject_class?(subject)
+    end
+    if @conditions.is_a?(::ActiveGraph::Node::Query::QueryProxy) || @conditions.is_a?(::ActiveGraph::Node::HasN::AssociationProxy)
+      return @conditions.where(id: subject.id).exists? unless subject_class?(subject)
+    end
+    # Don't stop at "cannot" definitions when there are conditions.
+    conditions_empty? ? true : @base_behavior
+  end
+
+  def conditions_empty?
+    (@conditions.is_a?(Hash) && @conditions == {}) || @conditions.nil?
+  end
+end

data/lib/cancancan/model_adapters/active_graph_adapter.rb

@@ -0,0 +1,124 @@
+require 'cancancan/active_graph/cypher_constructor_helper'
+require 'cancancan/active_graph/rule_cypher'
+require 'cancancan/active_graph/cypher_constructor'
+require 'cancancan/active_graph/single_rule_cypher'
+
+module CanCan
+  module ModelAdapters
+    # neo4j adapter for cancan
+    class ActiveGraphAdapter < AbstractAdapter
+      def database_records
+        return @model_class.where('false') if @rules.empty?
+        override_scope
+        if (rule = logical_single_can_rule)
+          return records_for_single_rule(rule)
+        end
+        records_for_multiple_rules.distinct
+      end
+
+      def self.for_class?(model_class)
+        model_class <= ActiveGraph::Node
+      end
+
+      def self.override_conditions_hash_matching?(_subject, _conditions)
+        true
+      end
+
+      def self.matches_conditions_hash?(subject, conditions)
+        base_class = subject.class
+        all_conditions_match?(subject, conditions, base_class)
+      end
+
+      def self.all_conditions_match?(subject, conditions, base_class)
+        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.property_matches?(subject, property, value)
+        if subject.is_a?(ActiveGraph::Node::HasN::AssociationProxy)
+          subject.where(property => value).exists?
+        else
+          subject.send(property) == value
+        end
+      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 logical_single_can_rule
+        return @rules.first if @rules.size == 1
+        return unless @rules.all?(&:base_behavior)
+        @rules.find do |rule|
+          conditions = rule.conditions
+          conditions.is_a?(Hash) && conditions.blank?
+        end
+      end
+
+      def records_for_single_rule(rule)
+        CanCanCan::ActiveGraph::SingleRuleCypher.new(rule, @model_class)
+                                          .records
+      end
+
+      def records_for_multiple_rules
+        con = CanCanCan::ActiveGraph::CypherConstructor.new(construct_cypher_options)
+        if (scope = con.scope)
+          return scope
+        end
+        con.query.proxy_as(@model_class, var_name)
+      end
+
+      def construct_cypher_options
+        @rules.reverse.collect.with_index do |rule, index|
+          opts = { rule: rule, model_class: @model_class, index: index }
+          CanCanCan::ActiveGraph::RuleCypher.new(opts)
+        end
+      end
+
+      def override_scope
+        conditions = @rules.map(&:conditions).compact
+        return unless conditions.any? do |condition|
+          condition.is_a?(ActiveGraph::Node::Query::QueryProxy)
+        end
+        return if conditions.size == 1
+        return if conditions.select { |cn| cn.is_a?(Hash) && !cn.empty? }.empty?
+        raise_override_scope_error
+      end
+
+      def raise_override_scope_error
+        rule_found = @rules.detect do |rule|
+          rule.conditions.is_a?(ActiveGraph::Node::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."
+      end
+
+      def var_name
+        CanCanCan::ActiveGraph::CypherConstructorHelper.var_name(@model_class)
+      end
+    end
+  end
+end
+
+module ActiveGraph
+  module Node
+    # simplest way to add `accessible_by` to all ActiveNode models
+    module ClassMethods
+      include CanCan::ModelAdditions::ClassMethods
+    end
+  end
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: cancancan-activegraph
+version: !ruby/object:Gem::Version
+  version: 3.0.1
+platform: ruby
+authors:
+- Amit Suryavanshi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activegraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 9.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 9.0.0
+- !ruby/object:Gem::Dependency
+  name: cancancan
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: neo4j-ruby-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: neo4j-rake_tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  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
+  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'
+  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'
+  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
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.48.1
+description: Implements CanCanCan's rule-based record fetching using neo4j gem.
+email:
+- amitbsuryavanshi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- cancancan-activegraph.gemspec
+- lib/cancancan/active_graph/active_record_disabler.rb
+- lib/cancancan/active_graph/cypher_constructor.rb
+- lib/cancancan/active_graph/cypher_constructor_helper.rb
+- lib/cancancan/active_graph/rule_cypher.rb
+- lib/cancancan/active_graph/single_rule_cypher.rb
+- lib/cancancan/active_graph/version.rb
+- lib/cancancan/activegraph.rb
+- lib/cancancan/extensions/ability.rb
+- lib/cancancan/extensions/conditions_matcher.rb
+- lib/cancancan/model_adapters/active_graph_adapter.rb
+homepage: https://github.com/CanCanCommunity/cancancan-activegraph
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: neo4j database adapter for CanCanCan.
+test_files: []