sparkql 1.2.8 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d6df2039c1c9c690fe60002b8374ec300e1ffab8496b02e668da3f77999d2e8
-  data.tar.gz: a529df747695e8c43a45bec3f166cc8e1b2cfa34a671173a998b4620fe522a67
+  metadata.gz: 0f8f460c07a1a833cd0a80040f686b12a9579db3bc0ae60d1cc7aa1c73fe644d
+  data.tar.gz: 66a6701ad74dc5454d9e4dd2a14c0ea133715e10ba5babb676c90aed62e917bd
 SHA512:
-  metadata.gz: e4a0fa65b7cb2b41198f239a6c68613939e3f6f0ce4ce20a9ae00b1ea4f7ae377cdd41b3b67f4a2da158344e33fa2d12d0a9cec7cc7c64a85a14e9f35bdffbdc
-  data.tar.gz: 746cfed6761f6bdc8ec7dfe91ad45b20d44fd6a67a7fe13e184406a8fab533c1a4122435242447da803160c4c4e3f05a8a8e61ba3a83ca568f2dd4d2b305ed1a
+  metadata.gz: 661e847ae1aa0f336706d94129c0afdc7d0ba040c0c8f62b7a6e9248dcc990d8f0179ef153355e050bae2b8a2f676c7e358081280418986c6c0bbf27393ac572
+  data.tar.gz: 4b64da6af2453236ec0b9c0e240238241609c79e0d4b8cca2c126ecc9b5e3b7e9c585836cc0dceb9a5136cb9decb993bffdef0145720de8dd734b2b2f291f340

data/.github/workflows/ci.yml

@@ -0,0 +1,51 @@
+name: CI
+
+on: 
+  push:
+    branches: [ master ]
+  pull_request:
+  release:
+    types: published
+  
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: ruby/setup-ruby@v1
+      with: 
+        ruby-version: '2.7'
+        bundler-cache: true
+  
+    - run: |
+       gem install bundler -v 2.2.31
+       ./script/ci_build
+
+  publish:
+    runs-on: ubuntu-latest
+    env:
+      RUBYGEMS_API_KEY: ${{secrets.RUBYGEMS_API_KEY}}
+
+    # only run if this is a release event
+    if: github.event_name == 'release'
+
+    # require that the build job passed
+    needs: build
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '2.7'
+
+    - run: |
+       ./script/bootstrap
+       bundle exec rake build
+
+       mkdir -p $HOME/.gem
+       touch $HOME/.gem/credentials
+       printf -- "---\n:rubygems_api_key: ${RUBYGEMS_API_KEY}\n" > $HOME/.gem/credentials
+       chmod 0600 $HOME/.gem/credentials
+       gem push pkg/*.gem

data/.rubocop.yml

@@ -0,0 +1,111 @@
+AllCops:
+  NewCops: disable
+  Exclude:
+    - 'bin/*'
+    - 'config/**/*'
+    - 'Rakefile'
+    - 'Capfile'
+    - 'Gemfile'
+    - 'Guardfile'
+    - 'test/factories/*'
+    - 'test/support/*'
+    - 'config/routes.rb'
+    - 'script/*'
+    - 'db/**/*'
+    - 'vendor/**/*'
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+# "Favor `unless` over `if` for negative conditions."
+Style/NegatedIf:
+  Enabled: false
+# safe_yaml seems to break all the things.
+Security/YAMLLoad:
+  Enabled: false
+
+# "Use a guard clause (`return unless extra_types.any?`) instead
+# of wrapping the code inside a conditional expression."
+#
+# Justification: guard clauses don't work very well with long lines.
+# Also, when there's an if check that (say) adds an error to a model
+# validation, it makes more sense to wrap the operation in an if block
+# than to guard the error entry with a double negative.
+Style/GuardClause:
+  Enabled: false
+
+# Justification:
+#
+# `class MyModule::ClassName` is a lot more concise, especially for tests
+# covering a class that is within a module, than having to wrap the whole
+# class in a module, and indent.
+#
+# "Use nested module/class definitions instead of compact style."
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+# Justification:
+#
+# A single-line guard clause isn't always a good thing.
+Style/IfUnlessModifier:
+  Enabled: false
+
+# Justification:
+#
+# Hundreds of existing infractions, and it's not really that confusion to
+# see regex without parens around it.
+Lint/AmbiguousRegexpLiteral:
+  Enabled: false
+
+# Justification:
+#
+# Is it so wrong to have a variable named fgo_listing_1, instead
+# of fgo_listing1?
+Naming/VariableNumber:
+  Enabled: false
+
+# Justification:
+#
+# Explicit else's are much clearer than
+# a branch that ends with an `elsif`, and presumes
+# a nil else.
+Style/EmptyElse:
+  Enabled: false
+
+# Justification:
+#
+# We've generally prefered this, and honestly, I find
+# this often makes readability much clearer to include
+# it.
+Style/RedundantSelf:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+2.7.2

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+v1.3.1, 2025-08-06
+-------------------
+  * [BUGFIX] Evaluator fix for Not expressions
+
+v1.3.0, 2022-02-01
+-------------------
+  * [BUGFIX] Redesign FunctionResolver to better support other timezones
+
 v1.2.8, 2021-08-11
 -------------------
   * [IMPROVEMENT] all() function

data/Gemfile

@@ -1,3 +1,3 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
 gemspec

data/Rakefile

@@ -15,7 +15,7 @@ rule '.rb' => '.y' do |t|
 end
 
 desc "Compile the racc parser from the grammar"
-task :compile => ["lib/sparkql/parser.rb", "grammar"]
+task compile: ["lib/sparkql/parser.rb", "grammar"]
 
 desc "Generate grammar Documenation"
 task :grammar do
@@ -27,5 +27,4 @@ Rake::Task[:test].prerequisites.unshift "lib/sparkql/parser.rb"
 Rake::Task[:test].prerequisites.unshift "grammar"
 
 desc 'Default: run unit tests.'
-task :default => :test
-
+task default: :test

data/VERSION

@@ -1 +1 @@
-1.2.8
+1.3.1

data/lib/sparkql/errors.rb

@@ -1,87 +1,84 @@
 module Sparkql
+  class ErrorsProcessor
+    attr_accessor :errors
 
-class ErrorsProcessor
-  attr_accessor :errors
+    def initialize(errors = [])
+      @errors = Array(errors)
+    end
 
-  def initialize( errors = [] )
-    @errors = Array(errors)
-  end
+    # true if the error stack contains at least one error
+    def errors?
+      @errors.size.positive?
+    end
 
-  # true if the error stack contains at least one error
-  def errors?
-    @errors.size > 0
-  end
+    # true if there is at least one error of status :status in the error stack
+    def errors_by_status?(status)
+      @errors.each do |error|
+        return true if status == error.status
+      end
+      false
+    end
 
-  # true if there is at least one error of status :status in the error stack
-  def errors_by_status?( status )
-    @errors.each do | error |
-      return true if status == error.status
+    # true if there is at least one :fatal error in the error stack
+    def fatal_errors?
+      errors_by_status? :fatal
     end
-    false
-  end
 
-  # true if there is at least one :fatal error in the error stack
-  def fatal_errors?
-    errors_by_status? :fatal
-  end
+    # true if there is at least one :dropped error in the error stack
+    def dropped_errors?
+      errors_by_status? :dropped
+    end
 
-  # true if there is at least one :dropped error in the error stack
-  def dropped_errors?
-    errors_by_status? :dropped
+    # true if there is at least one :recovered error in the error stack
+    def recovered_errors?
+      errors_by_status? :recovered
+    end
   end
 
-  # true if there is at least one :recovered error in the error stack
-  def recovered_errors?
-    errors_by_status? :recovered
-  end
+  class ParserError
+    attr_accessor :token, :token_index, :expression, :message, :status, :recovered_as,
+                  :sparkql, :nested_errors
+    attr_writer :syntax, :constraint
 
-end
+    def initialize(error_hash = {})
+      @token = error_hash[:token]
+      @token_index = error_hash[:token_index]
+      @expression = error_hash[:expression]
+      @message = error_hash[:message]
+      @status = error_hash[:status]
+      @recovered_as = error_hash[:recovered_as]
+      @recovered_as = error_hash[:recovered_as]
+      @sparkql = error_hash[:sparkql]
+      @nested_errors = error_hash[:nested_errors]
+      self.syntax = error_hash[:syntax] != false
+      self.constraint = error_hash[:constraint] == true
+    end
 
-class ParserError
-  attr_accessor :token, :token_index, :expression, :message, :status, :recovered_as,
-    :sparkql, :nested_errors
-  attr_writer :syntax, :constraint
+    def syntax?
+      @syntax
+    end
 
-  def initialize(error_hash={})
-    @token = error_hash[:token]
-    @token_index = error_hash[:token_index]
-    @expression = error_hash[:expression]
-    @message = error_hash[:message]
-    @status = error_hash[:status]
-    @recovered_as = error_hash[:recovered_as]
-    @recovered_as = error_hash[:recovered_as]
-    @sparkql = error_hash[:sparkql]
-    @nested_errors = error_hash[:nested_errors]
-    self.syntax= error_hash[:syntax] == false ? false : true
-    self.constraint= error_hash[:constraint] == true
-  end
-  
-  def syntax?
-    @syntax
-  end
-  
-  def constraint?
-    @constraint
-  end
+    def constraint?
+      @constraint
+    end
 
-  def to_s
-    str = case @status
-          # Do nothing. Dropping the expressions isn't special
-          when :dropped then "Dropped: " 
-          # Fatal errors cannot be recovered from, and should cause anaylisis or
-          # compilation to stop.
-          when :fatal then "Fatal: "
-          # Recovered errors are those that are syntatically
-          # or symantically incorrect, but are ones that we could "guess" at the
-          # intention
-          when :recovered then
-            "Recovered as #{@recovered_as}: "
-          else ""
-          end
-    str += "<#{@token}> in " unless @token.nil?
-    str += "<#{@expression}>: #{@message}."
-    str
+    def to_s
+      str = case @status
+            # Do nothing. Dropping the expressions isn't special
+            when :dropped then "Dropped: "
+            # Fatal errors cannot be recovered from, and should cause anaylisis or
+            # compilation to stop.
+            when :fatal then "Fatal: "
+            # Recovered errors are those that are syntatically
+            # or symantically incorrect, but are ones that we could "guess" at the
+            # intention
+            when :recovered
+              "Recovered as #{@recovered_as}: "
+            else ""
+            end
+      str += "<#{@token}> in " unless @token.nil?
+      str += "<#{@expression}>: #{@message}."
+      str
+    end
   end
 end
-
-end

data/lib/sparkql/evaluator.rb

@@ -4,148 +4,152 @@
 # 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
+  def initialize(expression_resolver)
     @resolver = expression_resolver
   end
 
   def evaluate(expressions)
     @processed_count = 0
-    @index = Node.new(0, 0, "And", 0, true, false, 0, nil)
-    @groups = [@index]
-    expressions.each do |expression|
-      handle_group(expression)
-      adjust_expression_for_dropped_field(expression)
-      check_for_good_ors(expression)
-      next if skip?(expression)
-      evaluate_expression(expression)
+    levels = {}
+    block_groups = {}
+
+    build_structures(levels, block_groups, expressions)
+
+    final_result = process_structures(levels, block_groups)
+    # If we didn't process anything, we consider that a success
+    if final_result.nil?
+      final_result = true
     end
-    cleanup
-    return @index[:match]
+
+    final_result
   end
 
   private
 
-  # prepare the group stack for the next expression
-  def handle_group(expression)
-    if @index[:block_group] == expression[:block_group]
-      # Noop
-    elsif @index[:block_group] < expression[:block_group]
-      @index = new_group(expression)
-      @groups.push(@index)
-    else
-      # Turn the group into an expression, resolve down to previous group(s)
-      smoosh_group(expression)
-    end
-  end
+  # Take all the expressions and organize them into "chunks" appropriate for
+  # evaluation. Each block group should process it's expressions, and every
+  # block group injects itself as a placeholder expression in the block group a
+  # level above it.
+  #
+  # When no block groups exist above, we must stub one out for processing.
+  def build_structures(levels, block_groups, expressions)
+    expressions.each do |expression|
+      level = expression[:level]
+      block = expression[:block_group]
+      block_group = block_groups[block]
 
-  # Here's the real meat. We use an internal stack to represent the result of
-  # each block_group. This logic is re-used when merging the final result of one
-  # block group with the previous.
-  def evaluate_expression(expression)
-      @processed_count += 1
-    evaluate_node(expression, @resolver.resolve(expression))
-  end
-  def evaluate_node(node, result)
-    if result == :drop
-      @dropped_expression = node
-      return result
-    end
-    if node[:unary] == "Not"
-      result = !result
-    end
-    if node[:conjunction] == 'Not' &&
-       (node[:conjunction_level] == node[:level] ||
-        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
-      @index[:match] = result
-    end
-    @index[:expressions] += 1
-    result
-  end
+      unless block_group
+        block_groups[block] ||= block_builder(expression, level)
+        block_group = block_groups[block]
+        levels[level] ||= []
+        levels[level] << block
 
-  # Optimization logic, once we find any set of And'd expressions that pass and
-  # run into an Or at the same level, we can skip further processing at that
-  # level.
-  def check_for_good_ors(expression)
-    if expression[:conjunction] == 'Or'
-      good_index = @index
-      unless expression[:conjunction_level] == @index[:level]
-        good_index = nil
-        # Well crap, now we need to go back and find that level by hand
-        @groups.reverse_each do |i|
-          if i[:level] == expression[:conjunction_level]
-            good_index = i
+        # When dealing with Not expression conjunctions at the block level,
+        # it's far simpler to convert it into the equivalent "And Not"
+        if block_group[:conjunction] == "Not"
+          block_group[:unary] = "Not"
+          block_group[:conjunction] = "And"
+        end
+
+        # Every block group _must_ be seen as an expression in another block
+        # group.This aids in final resolution order when processing the levels
+        #
+        # This is even true if there's only one block group. We always end up
+        # with a level -1 here to turn the top level expressions into a block
+        # group for processing.
+        current_level = level
+        while current_level >= 0
+          current_level -= 1
+          levels[current_level] ||= []
+          last_block_group_id = levels[current_level].last
+          if last_block_group_id
+            block_groups[last_block_group_id][:expressions] << block_group
+            break
+          else
+            block_id = "placeholder_for_#{block}_#{current_level}"
+            placeholder_block = block_builder(block_group, current_level)
+            placeholder_block[:expressions] << block_group
+
+            levels[current_level] << block_id
+            block_groups[block_id] = placeholder_block
           end
         end
       end
-      if !good_index.nil? && good_index[:expressions] > 0 && good_index[:match]
-        good_index[:good_ors] = true
-      end
+
+      block_group[:expressions] << expression
     end
   end
 
-  # We can skip further expression processing when And-d with a false expression
-  # or a "good Or" was already encountered.
-  def skip?(expression)
-    @index[:good_ors] ||
-      !@index[:match] && expression[:conjunction] == 'And'
-  end
+  # Starting from the deepest levels, we process block groups expressions and
+  # reduce the block group to a result. This result is used in our placeholder
+  # block groups at levels above, ending in a single final result.
+  def process_structures(levels, block_groups)
+    final_result = nil
 
-  def new_group(expression)
-    Node.new(expression[:level], expression[:block_group],
-      expression[:conjunction], expression[:conjunction_level],
-      true, false, 0, nil)
-  end
+    # Now go through each level starting with the deepest and working back up.
+    levels.keys.sort.reverse.each do |level|
+      # Process each block group  at this level and resolve the expressions in the group
+      levels[level].each do |block|
+        block_group = block_groups[block]
 
-  # 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?
-      return
-    elsif @dropped_expression[:block_group] == expression[:block_group]
-      expression[:conjunction] = @dropped_expression[:conjunction]
-      expression[:conjunction_level] = @dropped_expression[:conjunction_level]
-    end
-    @dropped_expression = nil
-  end
+        block_result = nil
+        block_group[:expressions].each do |expression|
+          # If we encounter any or's in the same block group, we can cheat at
+          # resolving the rest, if we are at a true
+          if block_result && expression[:conjunction] == 'Or'
+            break
+          end
+
+          expression_result = if expression.key?(:result)
+                                # This is a reduced block group, just pass on
+                                # the result
+                                expression[:result]
+                              else
+                                @processed_count += 1
+                                @resolver.resolve(expression) # true, false, :drop
+                              end
+          next if expression_result == :drop
+
+          if expression[:unary] == "Not"
+            expression_result = !expression_result
+          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
-  # nested group.
-  def smoosh_group(expression)
-    until  @groups.last[:block_group] == expression[:block_group]
-      last = @groups.pop
-      @index = @groups.last
-      evaluate_node(last, last[:match])
+          if block_result.nil?
+            block_result = expression_result
+            next
+          end
+
+          case expression[:conjunction]
+          when 'Not'
+            block_result &= !expression_result
+          when 'And'
+            block_result &= expression_result
+          when 'Or'
+            block_result |= expression_result
+          else
+            # Not a supported conjunction. We skip over this for backwards
+            # compatibility.
+          end
+        end
+
+        # block_group.delete(:expressions)
+        block_group[:result] = block_result
+        final_result = block_result
+      end
     end
+
+    final_result
   end
 
-  # pop off the group stack, evaluating each group with the previous as we go.
-  def cleanup
-    while @groups.size > 1
-      last = @groups.pop
-      @index = @groups.last
-      evaluate_node(last, last[:match])
-    end
-    @groups.last[:match]
+  def block_builder(expressionable, level)
+    {
+      conjunction: expressionable[:conjunction],
+      conjunction_level: expressionable[:conjunction_level],
+      level: level,
+      expressions: [],
+      result: nil
+    }
   end
 end

data/lib/sparkql/expression_resolver.rb

@@ -1,17 +1,16 @@
 # 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]
+  VALID_RESULTS = [true, false, :drop].freeze
 
   # Evaluate the result of this expression. Allows for any of the values in
   # VALID_RESULTS
-  def resolve(expression)
+  def resolve(_expression)
     true
   end
 end