cancancan-squeel 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edbfe73803fc60f8f004514ca962dcb92818cbb4
-  data.tar.gz: fc92e4d84a7557edf512293ebcfefd8995496d82
+  metadata.gz: ee0d8f0d270a3449f4c1373eb89857cc047553ea
+  data.tar.gz: ddc057b7c68e47e087dbed2b707005ccf581b6f7
 SHA512:
-  metadata.gz: ca8e2455b16e3bc007829341fffdce9682cdebfccc1089e1f0874a6edfcdc35433a955388814dd79b929e79a43e55b0b198fcd959587429d40fba178a4d9fe39
-  data.tar.gz: 9ea2d0969b402e28030d14b1a3c464aafaf8a34d13385056a9853bea7123b5b1e23e10d7ec602ba7f1894a06fbb6b2948fe1beaea158e841092d65bf726101e7
+  metadata.gz: 0756bbd6699c2eea5eee163425bcc389180028edfcad1b0c839e19bcfea821f0644987083d77069e3235e8db4d103143cb8125d1a5b897a360b669438f89a72d
+  data.tar.gz: 0db5510c60e8cfe778e6e6cd709ae95fd63ba47467c1b4f0a374561d749fc3a2dcd281530ef5f23020ca604dffaccce0968bc9bda86e7a839f8472fb174fb105

data/CHANGELOG.md

@@ -1,4 +1,10 @@
-## master
+## 0.1.3
+
+### enhancements
+
+ - Support ranges in conditions [@lowjoel](https://github.com/lowjoel) 
+
+## 0.1.2
 
 ### enhancements
 

data/lib/cancancan/squeel/attribute_mapper.rb

@@ -11,20 +11,34 @@ module CanCanCan::Squeel::AttributeMapper
   # 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, :==, 1..5) #=> [:&, [[:id, :>=, 1], [:id, :<=, 5]]]
+  # @example Association Objects
+  #   squeel_comparison_for(Post, :comment, :==, comment) #=> [:&, [[:comment_id, :==, 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, Symbol, Object)>] A triple containing the column to compare with, the
-  #   comparator to use, and the value to compare with.
+  # @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)
 
-    comparator = squeel_comparator_for(comparator, value)
-    [key, comparator, 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.
@@ -48,17 +62,70 @@ module CanCanCan::Squeel::AttributeMapper
   #
   # 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 [Symbol] The comparator for the desired effect, suitable for the given type.
+  # @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)
-    if value.is_a?(Array)
-      case comparator
-      when :== then :>>
-      when :!= then :<<
-      end
+    case value
+    when Array then comparator_for_array(comparator, value)
+    when Range then comparator_for_range(comparator, value)
+    else [:&, [[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 :== then [:&, [[:>>, value]]]
+    when :!= then [:&, [[:<<, 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
+      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 :== then [:&, [[:>=, value.first], [:<, value.last]]]
+    when :!= then [:|, [[:<, value.first], [:>=, 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 :== then [:&, [[:>=, value.first], [:<=, value.last]]]
+    when :!= then [:|, [[:<, value.first], [:>, value.last]]]
     end
   end
 end

data/lib/cancancan/squeel/expression_builder.rb

@@ -51,14 +51,45 @@ module CanCanCan::Squeel::ExpressionBuilder
   # @param value The value to compare the column against.
   def build_comparison_node(node, model_class, key, comparator, value)
     if value.is_a?(Hash)
-      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])]
+      build_association_comparison_node(node, model_class, key, comparator, value)
     else
-      key, comparator, value = CanCanCan::Squeel::AttributeMapper.
-                               squeel_comparison_for(model_class, key, comparator, value)
-      [node.__send__(key).public_send(comparator, value), []]
+      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::Squeel::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/squeel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module CanCanCan; end
 module CanCanCan::Squeel
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cancancan-squeel
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Joel Low