sparkql 1.1.0 → 1.1.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Y2ExNzBkYzg0N2RiZmFkOWRlMGI2NTg0NzJiOGQ5NzNlNTA2OTA5Mw==
+    ODFlYzJkZDViM2E4OWI2YmRmZDc0MTIyYTVmZDFlNzdhMzlkYzJkMg==
   data.tar.gz: !binary |-
-    YmYyYTBkZGQxMTFkNGZhNDg2MTA1NmZjN2M4YjcyZTZiMWQ0Njk5Ng==
+    YmYzYWIyZDJiZTRkZTYyZjg4NzQyYzYxZGI4OTQ1OWQzNDIzN2M4ZQ==
 SHA512:
   metadata.gz: !binary |-
-    Mzk4MmY3OTE2MzNiYmEyOTg3NGMzOTdhZTRjY2NhZjhmZjgxMzE1NTJkM2Vj
-    OWIxZGU0YTBjNTI3M2ZhZjUxNjdlOTY4MTgzMDRmNjhiOWE3MjEwNTU4YWU0
-    NmQ4MDYwZDRkMDIxYzkyNWI1MjQxMThhYTFiNGFmOTZmNzA1MjI=
+    MGRjNTRhZDU5NjQ1NmFkOGUzMjQ4M2JhOTNiY2Q1NTdiOWM2ODQ0NGVmYzY0
+    Yjk0OTQyZWEwY2I3ZGUyMTA3YWI4YmJkOTFjOGUzMDMyN2QwNWYzNjg1MTRl
+    OTNiOTkyNDY2OTYxYWI0ZDQ2YjUyMjZkYWRkZDgzNDI4NGViYTU=
   data.tar.gz: !binary |-
-    ZGEyMzQ1YzU2NDU5YjNhNmVkOTEwNjBlYTI2MWIxMmRiY2E3NWU1MjU3Nzg1
-    OTgxMzc3MTc3ZGI5Njc1NWZmNGJkY2FkMWNhZDdkNmY4NThkOWUyZmUzMWRj
-    NDViYmQzNzEzNjBkOThiMmViYjQ4YTRhNjBhYmVlYzE1NWQwMDg=
+    YTFjOTA1YjUyMzc2MWQzMTE5YWUzMDY5MjVjNGFhMDg5NzVmNTBjZDNkZDlm
+    YWJkMDBjNzYwNmI5MTcwY2QzZGYyNWEyODNiNDAzNTdiNTA3YjQ1NzQ4MTI1
+    YjIzYTdmZDQwNjA0OTFiNzhhNWJjODJjMTk1YzZhMjI5N2ZhNDk=

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+v1.1.1, 2016-09-09 ([changes](https://github.com/sparkapi/sparkql/compare/v1.1.0...v1.1.1))
+-------------------
+  * [BUGFIX] Fix `Not` handling in the new Evaluation class
+
 v1.1.0, 2016-07-28 ([changes](https://github.com/sparkapi/sparkql/compare/v1.0.3...v1.1.0))
 -------------------
   * [IMPROVEMENT] Evaluation class for sparkql boolean algebra processing

data/VERSION

@@ -1 +1 @@
-1.1.0
+1.1.1

data/lib/sparkql/evaluator.rb

@@ -1,10 +1,23 @@
 # Using an instance of ExpressionResolver to resolve the individual expressions,
 # this class will evaluate the rest of a parsed sparkql string to true or false.
-# Namely, this class will handle all the nesting, boolean algebra, and dropped 
+# Namely, this class will handle all the nesting, boolean algebra, and dropped
 # fields. Plus, it has some optimizations built in to skip the processing for
 # any expressions that don't contribute to the net result of the filter.
 class Sparkql::Evaluator
 
+  # The struct here mimics some of the parser information about an expression,
+  # but should not be confused for an expression. Nodes reduce the expressions
+  # to a result based on conjunction logic, and only one exists per block group.
+  Node = Struct.new(
+    :level,
+    :block_group,
+    :conjunction,
+    :conjunction_level,
+    :match,
+    :good_ors,
+    :expressions,
+    :unary)
+
   attr_reader :processed_count
 
   def initialize expression_resolver
@@ -13,15 +26,7 @@ class Sparkql::Evaluator
 
   def evaluate(expressions)
     @processed_count = 0
-    @index = {
-      level: 0,
-      block_group: 0,
-      conjunction: "And",
-      conjunction_level: 0,
-      match: true,
-      good_ors: false,
-      expressions: 0
-    }
+    @index = Node.new(0, 0, "And", 0, true, false, 0, nil)
     @groups = [@index]
     expressions.each do |expression|
       handle_group(expression)
@@ -66,8 +71,8 @@ class Sparkql::Evaluator
     end
     if node[:conjunction] == 'Not' &&
        (node[:conjunction_level] == node[:level] ||
-      node[:conjunction_level] == @index[:level])
-      @index[:match] = !result
+        node[:conjunction_level] == @index[:level])
+      @index[:match] = !result if @index[:match]
     elsif node[:conjunction] == 'And' || @index[:expressions] == 0
       @index[:match] = result if @index[:match]
     elsif node[:conjunction] == 'Or' && result
@@ -106,18 +111,12 @@ class Sparkql::Evaluator
   end
 
   def new_group(expression)
-    {
-      level: expression[:level],
-      block_group: expression[:block_group],
-      conjunction: expression[:conjunction],
-      conjunction_level: expression[:conjunction_level],
-      match: true,
-      good_ors: false,
-      expressions: 0
-    }
+    Node.new(expression[:level], expression[:block_group],
+      expression[:conjunction], expression[:conjunction_level],
+      true, false, 0, nil)
   end
 
-  # When the last expression was dropped, we need to repair the filter by 
+  # When the last expression was dropped, we need to repair the filter by
   # stealing the conjunction of that dropped field.
   def adjust_expression_for_dropped_field(expression)
     if @dropped_expression.nil?
@@ -129,8 +128,8 @@ class Sparkql::Evaluator
     @dropped_expression = nil
   end
 
-  # This is similar to the cleanup step, but happens when we return from a 
-  # nesting level. Before we can proceed, we need wrap up the result of the 
+  # This is similar to the cleanup step, but happens when we return from a
+  # nesting level. Before we can proceed, we need wrap up the result of the
   # nested group.
   def smoosh_group(expression)
     until  @groups.last[:block_group] == expression[:block_group]

data/lib/sparkql/expression_resolver.rb

@@ -1,6 +1,12 @@
 # Base class for handling expression resolution
 class Sparkql::ExpressionResolver
 
+  # Accepted results from the resolve method:
+  # * true and false reflect the expression's boolean result (as all expressions
+  #   should).
+  # * :drop is a special symbol indicating that the expression should be omitted
+  #   from the filter. Special rules apply for a dropped expression, such as
+  #   keeping the conjunction of the dropped expression.
   VALID_RESULTS = [true, false, :drop]
 
   # Evaluate the result of this expression. Allows for any of the values in

data/test/unit/evaluator_test.rb

@@ -21,6 +21,46 @@ class EvaluatorTest < Test::Unit::TestCase
     assert !sample("Test Eq false Or Test Eq false")
   end
 
+  # One passing or expression in the set should always affirm a match this tests
+  # every permutation of one passing expression
+  def test_ors_stay_good
+    5.times do |i|
+      expressions = []
+      5.times do |j|
+        expressions << "Test Eq #{i == j}"
+      end
+      filter = expressions.join(" Or ")
+      assert sample(filter), "Filter: #{filter}"
+    end
+  end
+
+  # One failing AND expression in a set should always fail. Here we ensure every
+  # permutation of one failing
+  def test_ands_stay_bad
+    5.times do |i|
+      expressions = []
+      5.times do |j|
+        expressions << "Test Eq #{i != j}"
+      end
+      filter = expressions.join(" And ")
+      assert !sample(filter), "Filter: #{filter}"
+    end
+  end
+  
+  # One failing Not expression in a set should always fail. Here we ensure every
+  # permutation of one failing
+  def test_nots_stay_bad
+    5.times do |i|
+      expressions = []
+      5.times do |j|
+        expressions << "Test Eq #{i == j}"
+      end
+      # Add the unary not to the front!
+      filter = "Not " + expressions.join(" Not ")
+      assert !sample(filter), "Filter: #{filter}"
+    end
+  end
+
   def test_dropped_field_handling
     assert sample("Test Eq 'Drop' And Test Eq true")
     assert !sample("Test Eq 'Drop' And Test Eq false")
@@ -57,6 +97,24 @@ class EvaluatorTest < Test::Unit::TestCase
     assert !sample("Test Eq true Not (Not Test Eq false)")
     assert sample("Not (Not Test Eq true)")
     assert sample("Not (Not(Not Test Eq true))")
+    assert !sample("Test Eq false And Test Eq true Not Test Eq false") 
+  end
+  
+  def test_examples
+    # This one is based on a real life example that had problems.
+    #
+    # CurrentPrice Bt 130000.00,180000.00 And PropertySubType Eq 'Single Family Residence' And 
+    # SchoolDistrict Eq 'Byron Center','Grandville','Jenison' And MlsStatus Eq 'Active' And 
+    # BathsTotal Bt 1.50,9999.00 And BedsTotal Bt 3,99 And PropertyType Eq 'A' 
+    # Not "Garage"."Garage2" Eq 'No' And "Pool"."OutdoorAbove" Eq true 
+    # And "Pool"."OutdoorInground" Eq true Not "Substructure"."Michigan Basement" Eq true
+
+    assert !sample("Test Eq false And Test Eq true And " + 
+      "Test Eq false And Test Eq true And " + 
+      "Test Eq true And Test Eq true And Test Eq true " + 
+      "Not Test Eq false And Test Eq false " + 
+      "And Test Eq false Not Test Eq false"
+    )
   end
 
   def test_optimizations

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sparkql
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Wade McEwen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-28 00:00:00.000000000 Z
+date: 2016-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: georuby