cancancan-baby_squeel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3b3caedaafaf77f1bcca26171be06f69ab78f32d
+  data.tar.gz: 54696f9993172b8801e76c46b910dff1d7d96652
+SHA512:
+  metadata.gz: 76c95bd79b2dada16c7b636a3fd31d5ffae04831c13e864a6a26146e291e46f5e0634b704f5a70d46fb7096b61ac8f3444bdf92c6d15add97678923c4aa797d0
+  data.tar.gz: 1e14a168786c8b5fe7b6dc29e999126b2d964d961ae217acec2cf7b8901c232148988a77661002b65f48dd8fcb6fae5d52287013d75cc4021d8acc04cf9cd74a

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# Ignore generated code coverage information
+/spec/coverage/*
+/coverage/*
+
+# Ignore RSpec state
+/spec/examples.txt

data/.hound.yml

@@ -0,0 +1,2 @@
+ruby:
+  config_file: .rubocop.yml

data/.idea/cancancan-squeel.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RUBY_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.bundle" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.unhound.yml

@@ -0,0 +1,109 @@
+Style/CollectionMethods:
+  Enabled: true
+  PreferredMethods:
+    reduce:
+    inject: 'reduce'
+    find:
+    detect: 'find'
+
+Style/FileName:
+  Enabled: true
+
+Style/GuardClause:
+  Enabled: true
+
+Style/IfUnlessModifier:
+  Enabled: true
+
+Style/PercentLiteralDelimiters:
+  Enabled: true
+
+Style/SignalException:
+  Enabled: true
+
+Style/SingleLineBlockParams:
+  Enabled: true
+
+Style/SingleLineMethods:
+  Enabled: true
+
+Style/TrailingCommaInArguments:
+  Enabled: true
+
+Style/TrailingCommaInLiteral:
+  Enabled: true
+
+Metrics/AbcSize:
+  Enabled: true
+
+Metrics/ClassLength:
+  Enabled: true
+
+Metrics/ModuleLength:
+  Enabled: true
+
+Metrics/CyclomaticComplexity:
+  Enabled: true
+
+Metrics/MethodLength:
+  Enabled: true
+
+Metrics/ParameterLists:
+  Enabled: true
+
+Metrics/PerceivedComplexity:
+  Enabled: true
+
+Lint/AssignmentInCondition:
+  Enabled: true
+
+Style/AccessorMethodName:
+  Enabled: true
+
+Style/Alias:
+  Enabled: true
+  EnforcedStyle: prefer_alias_method
+
+Style/Documentation:
+  Enabled: true
+
+Style/DoubleNegation:
+  Enabled: true
+
+Style/EachWithObject:
+  Enabled: true
+
+Style/EmptyLiteral:
+  Enabled: true
+
+Style/ModuleFunction:
+  Enabled: true
+
+Style/OneLineConditional:
+  Enabled: true
+
+Style/PerlBackrefs:
+  Enabled: true
+
+Style/SpecialGlobalVars:
+  Enabled: true
+
+Style/VariableInterpolation:
+  Enabled: true
+
+Style/WhenThen:
+  Enabled: true
+
+Lint/EachWithObjectArgument:
+  Enabled: true
+
+Lint/HandleExceptions:
+  Enabled: true
+
+Lint/LiteralInCondition:
+  Description: Checks of literals used in conditions.
+  Enabled: true
+
+Lint/LiteralInInterpolation:
+  Description: Checks for literals used in interpolation.
+  Enabled: true

data/.rubocop.yml

@@ -0,0 +1,46 @@
+inherit_from:
+  - .rubocop.unhound.yml
+
+AllCops:
+  Include:
+    - '**/Gemfile'
+    - '**/Rakefile'
+  Exclude:
+   - 'vendor/bundle/**/*'
+  TargetRubyVersion: 2.1
+
+Metrics/LineLength:
+  Max: 100
+
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact
+
+Style/DotPosition:
+  EnforcedStyle: trailing
+
+Style/Documentation:
+  Enabled: false
+
+Style/IndentHash:
+  EnforcedStyle: consistent
+
+Style/IfUnlessModifier:
+  MaxLineLength: 100
+
+Style/ParallelAssignment:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/WhileUntilModifier:
+  MaxLineLength: 100
+
+Style/WordArray:
+  Enabled: false
+
+Style/RegexpLiteral:
+  AllowInnerSlashes: true
+
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 2.4.2
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+bundler_args: "--jobs=3 --retry=3"
+cache: bundler
+
+before_install:
+  - gem update bundler

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## master
+
+## 0.1.0
+
+Initial release -
+Modifications to support baby_squeel. [@jeremyyap](https://github.com/jeremyyap)
+Code based on cancancan-squeel, credits to original author. [@lowjoel](https://github.com/lowjoel)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cancancan-squeel.gemspec
+gemspec

data/README.md

@@ -0,0 +1,24 @@
+# CanCanCan-BabySqueel
+[![Build Status](https://travis-ci.org/Coursemology/cancancan-baby_squeel.svg?branch=master)](https://travis-ci.org/Coursemology/cancancan-baby_squeel)
+[![Coverage Status](https://coveralls.io/repos/github/Coursemology/cancancan-baby_squeel/badge.svg?branch=master)](https://coveralls.io/github/Coursemology/cancancan-baby_squeel?branch=master)
+
+This is an adapter for the [CanCanCan](https://github.com/CanCanCommunity/cancancan) authorisation
+library to automatically generate SQL queries from ability rules.
+
+This differs from the default ActiveRecord implementation in that it uses
+[baby_squeel](https://github.com/rzane/baby_squeel) to generate SQL queries. This no longer
+uses
+ - `includes` (which incurs eager loading overhead)
+ - `WHERE` fragments, joined lexically using `OR` or `AND` or `NOT`.
+
+As a side effect of using `squeel`, this allows self-joins in rule definitions.
+
+## Usage
+
+In your `Gemfile`, insert the following line:
+
+```ruby
+gem 'cancancan-baby_squeel'
+```
+
+after you included `cancancan`.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/cancancan-baby_squeel.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cancancan/baby_squeel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cancancan-baby_squeel'
+  spec.version       = CanCanCan::BabySqueel::VERSION
+  spec.authors       = ['Jeremy Yap']
+  spec.email         = ['jeremy.yapjl@gmail.com']
+  spec.license       = 'MIT'
+
+  spec.summary       = 'BabySqueel database adapter for CanCanCan.'
+  spec.description   = "Implements CanCanCan's rule-based record fetching using BabySqueel."
+  spec.homepage      = 'https://github.com/jeremyyap/cancancan-baby_squeel'
+
+  spec.files         = `git ls-files -z`.split("\x0").
+                       reject { |f| f.match(/^(test|spec|features)\//) }
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'coveralls'
+
+  spec.add_development_dependency 'sqlite3'
+
+  spec.add_dependency 'activerecord', '>= 4.1'
+  spec.add_dependency 'cancancan', '>= 1.10'
+  spec.add_dependency 'baby_squeel', '~> 1.1.5'
+end

data/lib/cancancan/baby_squeel.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require 'active_record'
+require 'cancancan'
+require 'baby_squeel'
+
+require 'cancancan/baby_squeel/version'
+require 'cancancan/baby_squeel/active_record_disabler'
+require 'cancancan/baby_squeel/attribute_mapper'
+require 'cancancan/baby_squeel/expression_builder'
+require 'cancancan/baby_squeel/expression_combinator'
+require 'cancancan/baby_squeel/baby_squeel_adapter'

data/lib/cancancan/baby_squeel/active_record_disabler.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+class CanCanCan::BabySqueel::ActiveRecordDisabler
+  ::CanCan::ModelAdapters::ActiveRecord4Adapter.class_eval do
+    def self.for_class?(_)
+      false
+    end
+  end
+end

data/lib/cancancan/baby_squeel/attribute_mapper.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+# Implements mapping attributes, values, and comparators for a given model to appropriate
+# database equivalents.
+#
+# This implements:
+#  - comparing values against an array: interpreted as any value for ==, none of the values for !=.
+#  - mapping foreign keys to IDs
+module CanCanCan::BabySqueel::AttributeMapper
+  module_function
+
+  # Picks the appropriate column, comparator, and value to use in the Squeel expression.
+  #
+  # This checks for association references: this will use the appropriate column name.
+  # Array values are interpreted as alternative choices allowed or disallowed.
+  # Ranges are converted to appropriate comparator pairs.
+  #
+  # The return value is a tuple:
+  #
+  #  - The first element is a combinator to be used on the comparisons.
+  #  - The second element is an array of comparisons: each comparison is a tuple of
+  #    (key, comparator, value)
+  #
+  # The appropriate expression is the combination of all the comparisons, using the combinator
+  # returned.
+  #
+  # @example Attribute Ranges
+  #   squeel_comparison_for(User, :id, :eq, 1..5) #=> [:and, [[:id, :gteq, 1], [:id, :lteq, 5]]]
+  # @example Association Objects
+  #   squeel_comparison_for(Post, :comment, :eq, comment) #=> [:and, [[:comment_id, :eq, 1]]]
+  #
+  # @param [Class] model_class The model class which the key references.
+  # @param [Symbol] key The column being compared.
+  # @param [Symbol] comparator The comparator to get the appropriate Squeel comparator for.
+  # @param value The value to be comparing against.
+  # @return [Array<(Symbol, Array<(Symbol, Symbol, Object)>)>] A tuple containing the combinator for
+  #   the comparisons, and a sequence of comparisons.
+  def squeel_comparison_for(model_class, key, comparator, value)
+    key, value = map_association(model_class, key, value)
+
+    combinator, comparisons = squeel_comparator_for(comparator, value)
+    [combinator, comparisons.map { |comp| comp.unshift(key) }]
+  end
+
+  # Picks the table column to compare the value against for the given key.
+  #
+  # This sets associations to use the proper foreign key column.
+  #
+  # @param [Class] model_class The model class which the key references.
+  # @param [Symbol] key The column being compared.
+  # @param value The value to be comparing against.
+  # @return [Array<(Symbol, Object)>] A tuple containing the column to compare with and the value
+  #   to compare with.
+  def map_association(model_class, key, value)
+    if (association = model_class.reflect_on_association(key))
+      key = association.foreign_key
+      value = value.id
+    end
+
+    [key, value]
+  end
+
+  # Maps the given comparator to a comparator appropriate for the given value.
+  #
+  # Array values are interpreted as alternative choices allowed or disallowed.
+  #
+  # Ranges are interpreted as start/end pairs, respecting the exclusion of the end point.
+  #
+  # @param [Symbol] comparator The comparator to get the appropriate Squeel comparator for.
+  # @param value The value to be comparing against.
+  # @return [Array<Array<(Symbol, Object)>>] An array of comparisons, each with the comparator
+  #   to use, and the value to compare against.
+  def squeel_comparator_for(comparator, value)
+    case value
+    when Array then comparator_for_array(comparator, value)
+    when Range then comparator_for_range(comparator, value)
+    else [:and, [[comparator, value]]]
+    end
+  end
+
+  # Maps the given comparator to the IN/NOT IN operator.
+  #
+  # @param [Symbol] comparator The comparator to get the SqueeL comparator for.
+  # @param [Array] value The acceptable/rejected values.
+  # @return [Array<(Symbol, Array<(Symbol, Object)>)>] The combinator, and an array of comparisons,
+  #   each with the comparator to use, and the value to compare against.
+  def comparator_for_array(comparator, value)
+    case comparator
+    when :eq then [:and, [[:in, value]]]
+    when :not_eq then [:and, [[:not_in, value]]]
+    end
+  end
+
+  # Maps the given comparator to a range comparison.
+  #
+  # @param [Symbol] comparator The comparator to get the Squeel comparator for.
+  # @param [Range] value The acceptable/rejected values.
+  # @return [Array<(Symbol, Array<(Symbol, Object)>)>] The combinator, and an array of comparisons,
+  #   each with the comparator to use, and the value to compare against.
+  def comparator_for_range(comparator, value)
+    if value.exclude_end?
+      comparator_for_exclusive_range(comparator, value)
+    else
+      comparator_for_inclusive_range(comparator, value)
+    end
+  end
+
+  # Maps the given comparator to a range comparison.
+  #
+  # @param [Symbol] comparator The comparator to get the Squeel comparator for.
+  # @param [Range] value The acceptable/rejected values.
+  # @return [Array<Array<(Symbol, Object)>>] An array of comparisons, each with the comparator
+  #   to use, and the value to compare against.
+  def comparator_for_exclusive_range(comparator, value)
+    case comparator
+    when :eq then [:and, [[:gteq, value.first], [:lt, value.last]]]
+    when :not_eq then [:or, [[:lt, value.first], [:gteq, value.last]]]
+    end
+  end
+
+  # Maps the given comparator to a range comparison.
+  #
+  # @param [Symbol] comparator The comparator to get the Squeel comparator for.
+  # @param [Range] value The acceptable/rejected values.
+  # @return [Array<Array<(Symbol, Object)>>] An array of comparisons, each with the comparator
+  #   to use, and the value to compare against.
+  def comparator_for_inclusive_range(comparator, value)
+    case comparator
+    when :eq then [:and, [[:gteq, value.first], [:lteq, value.last]]]
+    when :not_eq then [:or, [[:lt, value.first], [:gt, value.last]]]
+    end
+  end
+end

data/lib/cancancan/baby_squeel/baby_squeel_adapter.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+class CanCanCan::BabySqueel::BabySqueelAdapter < CanCan::ModelAdapters::AbstractAdapter
+  include CanCanCan::BabySqueel::ExpressionCombinator
+
+  ALWAYS_TRUE = CanCanCan::BabySqueel::ExpressionCombinator::ALWAYS_TRUE
+  ALWAYS_FALSE = CanCanCan::BabySqueel::ExpressionCombinator::ALWAYS_FALSE
+
+  def self.for_class?(model_class)
+    model_class <= ActiveRecord::Base
+  end
+
+  def self.override_condition_matching?(subject, name, _)
+    match_relation?(subject, name) || match_enum?(subject, name)
+  end
+
+  def self.matches_condition?(subject, name, value)
+    if match_relation?(subject, name)
+      matches_relation?(subject, name, value)
+    elsif match_enum?(subject, name)
+      matches_enum?(subject, name, value)
+    else
+      false
+    end
+  end
+
+  # Overrides condition matching for enums.
+  def self.match_enum?(subject, name)
+    klass = subject.class
+    klass.respond_to?(:defined_enums) && klass.defined_enums.include?(name.to_s)
+  end
+  private_class_method :match_enum?
+
+  # Overrides condition matching for enums.
+  def self.matches_enum?(subject, name, value)
+    # Get the mapping from enum strings to values.
+    enum = subject.class.public_send(name.to_s.pluralize)
+
+    # Get the value of the attribute as an integer.
+    attribute = enum[subject.public_send(name)]
+
+    # Check to see if the value matches the condition.
+    value.is_a?(Enumerable) ? value.include?(attribute) : attribute == value
+  end
+  private_class_method :matches_enum?
+
+  def self.match_relation?(subject, name)
+    subject_attribute = subject.public_send(name)
+    subject_attribute.is_a?(ActiveRecord::Relation) && !subject_attribute.loaded
+  end
+  private_class_method :match_relation?
+
+  def self.matches_relation?(subject, name, value)
+    relation = subject.public_send(name)
+    klass = subject.class.reflect_on_association(name).klass
+    join_list = nil
+
+    scope = relation.where.has do
+      expression, join_list = CanCanCan::BabySqueel::ExpressionBuilder.build(self, klass, :eq, value)
+      expression
+    end
+
+    add_joins_to_scope(scope, join_list, :inner).any?
+  end
+  private_class_method :matches_relation?
+
+  def database_records
+    # TODO: Handle overridden scopes.
+    relation.distinct
+  end
+
+  # Builds a relation, outer joined on the provided associations.
+  #
+  # @param [ActiveRecord::Relation] scope The current scope to add the joins to.
+  # @param [Array<Array<Symbol>>] joins The set of associations to outer join with.
+  # @param [Symbol] join_type The type of join; defaults to outer joins.
+  # @return [ActiveRecord::Relation] The built relation.
+  def self.add_joins_to_scope(scope, joins, join_type = :outer)
+    joins.reduce(scope) do |result, join|
+      result.joining do
+        join.reduce(self) do |relation, association|
+          relation = relation.__send__(association)
+          relation = relation.__send__(join_type) unless join_type == :inner
+          relation
+        end
+      end
+    end
+  end
+  private_class_method :add_joins_to_scope
+
+  private
+
+  # Builds a relation that expresses the set of provided rules.
+  #
+  # The required Squeel expression is built, then the joins which are necessary to satisfy the
+  # expressions are added to the query scope.
+  def relation
+    adapter = self
+    join_list = nil
+    scope = @model_class.where(nil).where.has do
+      expression, join_list = adapter.send(:build_accessible_by_expression, self)
+      expression
+    end
+
+    add_joins_to_scope(scope, join_list)
+  end
+
+  # @see CanCanCan::BabySqueel::BabySqueelAdapter.add_joins_to_scope
+  def add_joins_to_scope(*args)
+    self.class.send(:add_joins_to_scope, *args)
+  end
+
+  # This builds Squeel expression for each rule, and combines the expression with those to the left
+  # using a fold-left.
+  #
+  # The rules provided by Cancancan are in reverse order, i.e. the lowest priority rule is first.
+  #
+  # @param squeel The Squeel scope.
+  # @return [Array<(Squeel::Nodes::Node, Array<Array<Symbol>>)>] A tuple containing the Squeel
+  #   expression, as well as an array of joins which the Squeel expression must be joined to.
+  def build_accessible_by_expression(squeel)
+    @rules.reverse.reduce([ALWAYS_FALSE, []]) do |(left_expression, joins), rule|
+      combine_expression_with_rule(squeel, left_expression, joins, rule)
+    end
+  end
+
+  # Combines the given expression with the new rule.
+  #
+  # @param squeel The Squeel scope.
+  # @param left_expression The Squeel expression for all preceding rules.
+  # @param [Array<Array<Symbol>>] joins An array of joins which the Squeel expression must be
+  #   joined to.
+  # @param [CanCan::Rule] rule The rule being added.
+  # @return [Array<(Squeel::Nodes::Node, Array<Array<Symbol>>)>] A tuple containing the Squeel
+  #   expression, as well as an array of joins which the Squeel expression must be joined to.
+  def combine_expression_with_rule(squeel, left_expression, joins, rule)
+    right_expression, right_expression_joins = build_expression_from_rule(squeel, rule)
+    operator = rule.base_behavior ? :or : :and
+
+    expression, joins = combine_squeel_expressions(left_expression, joins, operator, right_expression,
+                                                   right_expression_joins)
+
+    squeel._scope = add_joins_to_scope(squeel._scope, joins)
+    [expression, joins]
+  end
+
+  # Builds a Squeel expression representing the rule's conditions.
+  #
+  # @param squeel The Squeel scope.
+  # @param [CanCan::Rule] rule The rule being built.
+  # @return [Array<(Squeel::Nodes::Node, Array<Array<Symbol>>)>] A tuple containing the Squeel
+  #   expression representing the rule's conditions, as well as an array of joins which the Squeel
+  #   expression must be joined to.
+  def build_expression_from_rule(squeel, rule)
+    if rule.conditions.empty?
+      [rule.base_behavior ? ALWAYS_TRUE : ALWAYS_FALSE, []]
+    else
+      comparator = rule.base_behavior ? :eq : :not_eq
+      CanCanCan::BabySqueel::ExpressionBuilder.build(squeel, @model_class, comparator, rule.conditions)
+    end
+  end
+end

data/lib/cancancan/baby_squeel/expression_builder.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+# Builds Squeel expressions from the given scope, model class, and a hash of conditions.
+#
+# This is used by building a set of rules for retrieving all accessible records, as well as for
+# building queries instead of loading all records into memory.
+module CanCanCan::BabySqueel::ExpressionBuilder
+  module_function
+
+  # Builds a new Squeel expression node given a model class, the comparator, and the conditions.
+  #
+  # @param squeel The Squeel context. This is the value of +self+ within a +where+ DSL block.
+  # @param [Class] model_class The model class which the conditions reference.
+  # @param [Symbol] comparator The comparator to use when generating the comparison.
+  # @param [Hash] conditions The values to compare the given node's attributes against.
+  # @return [Array<(Squeel::Nodes::Node, Array<Array<Symbol>>)>] A tuple containing the Squeel
+  #   expression representing the rule's conditions, as well as an array of joins which the Squeel
+  #   expression must be joined to.
+  def build(squeel, model_class, comparator, conditions)
+    build_expression_node(squeel, model_class, comparator, conditions, true)
+  end
+
+  # Builds a new Squeel expression node.
+  #
+  # @param node The parent node context.
+  # @param [Class] model_class The model class which the conditions reference.
+  # @param [Symbol] comparator The comparator to use when generating the comparison.
+  # @param [Hash] conditions The values to compare the given node's attributes against.
+  # @param [Boolean] root True if the node being built is from the root. The root node is special
+  #   because it does not mutate itself; all other nodes do.
+  # @return [Array<(Squeel::Nodes::Node, Array<Array<Symbol>>)>] A tuple containing the Squeel
+  #   expression representing the rule's conditions, as well as an array of joins which the Squeel
+  #   expression must be joined to.
+  def build_expression_node(node, model_class, comparator, conditions, root = false)
+    conditions.reduce([nil, []]) do |(left_expression, joins), (key, value)|
+      comparison_node, node_joins = build_comparison_node(root ? node : node.dup, model_class,
+                                                          key, comparator, value)
+      if left_expression
+        [left_expression.and(comparison_node), joins.concat(node_joins)]
+      else
+        [comparison_node, node_joins]
+      end
+    end
+  end
+
+  # Builds a comparison node for the given key and value.
+  #
+  # @param node The node context to build the comparison.
+  # @param [Class] model_class The model class which the conditions reference.
+  # @param [Symbol] key The column to compare against.
+  # @param [Symbol] comparator The comparator to compare the column against the value.
+  # @param value The value to compare the column against.
+  def build_comparison_node(node, model_class, key, comparator, value)
+    if value.is_a?(Hash)
+      build_association_comparison_node(node, model_class, key, comparator, value)
+    else
+      build_scalar_comparison_node(node, model_class, key, comparator, value)
+    end
+  end
+
+  # Builds a comparison node for the given association and association attributes.
+  #
+  # @param node The node context to build the comparison.
+  # @param [Class] model_class The model class which the conditions reference.
+  # @param [Symbol] key The association to compare against.
+  # @param [Symbol] comparator The comparator to compare the column against the value.
+  # @param [Hash] value The attributes to compare the column against.
+  def build_association_comparison_node(node, model_class, key, comparator, value)
+    reflection_class = model_class.reflect_on_association(key).klass
+    expression, joins = build_expression_node(node.__send__(key), reflection_class, comparator,
+                                              value)
+    [expression, joins.map { |join| join.unshift(key) }.unshift([key])]
+  end
+
+  # Builds a comparison node for the given attribute and value.
+  #
+  # @param node The node context to build the comparison.
+  # @param [Class] model_class The model class which the conditions reference.
+  # @param [Symbol] key The column to compare against.
+  # @param [Symbol] comparator The comparator to compare the column against the value.
+  # @param value The value to compare the column against.
+  def build_scalar_comparison_node(node, model_class, key, comparator, value)
+    combinator, comparisons = CanCanCan::BabySqueel::AttributeMapper.
+                              squeel_comparison_for(model_class, key, comparator, value)
+    attribute = node.__send__(comparisons.first.first)
+
+    expression = comparisons.reduce(nil) do |left_expression, (_, comparator, value)|
+      right_expression = attribute.dup.public_send(comparator, value)
+      next right_expression unless left_expression
+
+      left_expression.public_send(combinator, right_expression)
+    end
+
+    [expression, []]
+  end
+end

data/lib/cancancan/baby_squeel/expression_combinator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+module CanCanCan::BabySqueel::ExpressionCombinator
+  # This true expression is used to indicate a condition that is always satisfied.
+  ALWAYS_TRUE = Arel::Nodes::SqlLiteral.new('1=1').freeze
+
+  # This true expression is used to indicate a condition that is never satisfied.
+  ALWAYS_FALSE = Arel::Nodes::SqlLiteral.new('1=0').freeze
+
+  # Combines two Squeel expressions. This is aware of the +ALWAYS_TRUE+ and +ALWAYS_FALSE+
+  # constants and performs simplification.
+  #
+  # @param [Squeel::Nodes::Node] left_expression The left expression.
+  # @param [Array] left_expression_joins An array of joins which the Squeel expression must be
+  #   joined to.
+  # @param [Symbol] operator The operator to combine with. This must be either +:and+ or +:or+.
+  # @param [Squeel::Nodes::Node] right_expression The right expression.
+  # @param [Array] right_expression_joins An array of joins which the Squeel expression must be
+  #   joined to.
+  # @return [Array<(Squeel::Nodes::Node, Array)>] A tuple containing the combination of the given
+  #   expressions, as well as an array of joins which the Squeel expression must be joined to.
+  def combine_squeel_expressions(left_expression, left_expression_joins, operator,
+                                 right_expression, right_expression_joins)
+    case operator
+    when :and then conjunction_expressions(left_expression, left_expression_joins,
+                                         right_expression, right_expression_joins)
+    when :or then disjunction_expressions(left_expression, left_expression_joins,
+                                         right_expression, right_expression_joins)
+    else
+      raise ArgumentError, "#{operator} must either be :and or :or"
+    end
+  end
+
+  # Computes the conjunction of the two Squeel expressions.
+  #
+  # Boolean simplification is done for the +ALWAYS_TRUE+ and +ALWAYS_FALSE+ values.
+  # @param [Squeel::Nodes::Node] left_expression The left expression.
+  # @param [Array] left_expression_joins An array of joins which the Squeel expression must be
+  #   joined to.
+  # @param [Squeel::Nodes::Node] right_expression The right expression.
+  # @param [Array] right_expression_joins An array of joins which the Squeel expression must be
+  #   joined to.
+  # @return [Array<(Squeel::Nodes::Node, Array)>] A tuple containing the conjunction of the left and
+  #   right expressions, as well as an array of joins which the Squeel expression must be joined to.
+  def conjunction_expressions(left_expression, left_expression_joins, right_expression,
+                              right_expression_joins)
+    if left_expression == ALWAYS_FALSE || right_expression == ALWAYS_FALSE
+      [ALWAYS_FALSE, []]
+    elsif left_expression == ALWAYS_TRUE
+      [right_expression, right_expression_joins]
+    elsif right_expression == ALWAYS_TRUE
+      [left_expression, left_expression_joins]
+    else
+      [left_expression.and(right_expression), left_expression_joins + right_expression_joins]
+    end
+  end
+
+  # Computes the disjunction of the two Squeel expressions.
+  #
+  # Boolean simplification is done for the +ALWAYS_TRUE+ and +ALWAYS_FALSE+ values.
+  # @param [Squeel::Nodes::Node] left_expression The left expression.
+  # @param [Array] left_expression_joins An array of joins which the Squeel expression must be
+  #   joined to.
+  # @param [Squeel::Nodes::Node] right_expression The right expression.
+  # @param [Array] right_expression_joins An array of joins which the Squeel expression must be
+  #   joined to.
+  # @return [Array<(Squeel::Nodes::Node, Array)>] A tuple containing the disjunction of the left and
+  #   right expressions, as well as an array of joins which the Squeel expression must be joined to.
+  def disjunction_expressions(left_expression, left_expression_joins, right_expression,
+                              right_expression_joins)
+    if left_expression == ALWAYS_TRUE || right_expression == ALWAYS_TRUE
+      [ALWAYS_TRUE, []]
+    elsif left_expression == ALWAYS_FALSE
+      [right_expression, right_expression_joins]
+    elsif right_expression == ALWAYS_FALSE
+      [left_expression, left_expression_joins]
+    else
+      [left_expression.or(right_expression), left_expression_joins + right_expression_joins]
+    end
+  end
+end

data/lib/cancancan/baby_squeel/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module CanCanCan; end
+module CanCanCan::BabySqueel
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: cancancan-baby_squeel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jeremy Yap
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: cancancan
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: baby_squeel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+description: Implements CanCanCan's rule-based record fetching using BabySqueel.
+email:
+- jeremy.yapjl@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".hound.yml"
+- ".idea/cancancan-squeel.iml"
+- ".rspec"
+- ".rubocop.unhound.yml"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- cancancan-baby_squeel.gemspec
+- lib/cancancan/baby_squeel.rb
+- lib/cancancan/baby_squeel/active_record_disabler.rb
+- lib/cancancan/baby_squeel/attribute_mapper.rb
+- lib/cancancan/baby_squeel/baby_squeel_adapter.rb
+- lib/cancancan/baby_squeel/expression_builder.rb
+- lib/cancancan/baby_squeel/expression_combinator.rb
+- lib/cancancan/baby_squeel/version.rb
+homepage: https://github.com/jeremyyap/cancancan-baby_squeel
+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.6.8
+signing_key: 
+specification_version: 4
+summary: BabySqueel database adapter for CanCanCan.
+test_files: []