sparkql 1.2.8 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d6df2039c1c9c690fe60002b8374ec300e1ffab8496b02e668da3f77999d2e8
-  data.tar.gz: a529df747695e8c43a45bec3f166cc8e1b2cfa34a671173a998b4620fe522a67
+  metadata.gz: 5988efc1b20cbe3cd2baec8537c3d9331564962a1d502d2ceaf63d78f520d218
+  data.tar.gz: e1b20183b39463bf221eeddbcbdbb32a3d06457f2108c5c2ae6da471fdfdebf3
 SHA512:
-  metadata.gz: e4a0fa65b7cb2b41198f239a6c68613939e3f6f0ce4ce20a9ae00b1ea4f7ae377cdd41b3b67f4a2da158344e33fa2d12d0a9cec7cc7c64a85a14e9f35bdffbdc
-  data.tar.gz: 746cfed6761f6bdc8ec7dfe91ad45b20d44fd6a67a7fe13e184406a8fab533c1a4122435242447da803160c4c4e3f05a8a8e61ba3a83ca568f2dd4d2b305ed1a
+  metadata.gz: 707c7f59f776ff70d9c4d164c4177a4800a81da80b2a0b4c7a99fdf7f1c7e632a67e155f11ead5c836fb48cc2ceec364adb8d359ecea6d714cc86f2bea2e0c58
+  data.tar.gz: e74cf6657fd5e9cd81dbd23cbdb07c0506ac84280d7651d1b07e11dc8656f56105bde0b6273e7d4fdfd83a91edaa1742e77a4ce6717ca94daf60e5124c34f313

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.5.8

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+v1.3.0, 2022-02-01
+-------------------
+  * [BUGFIX] Redesign FunctionResolver to better support other timezones
+
 v1.2.8, 2021-08-11
 -------------------
   * [IMPROVEMENT] all() function

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.0

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,7 +4,6 @@
 # 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.
@@ -16,15 +15,17 @@ class Sparkql::Evaluator
     :match,
     :good_ors,
     :expressions,
-    :unary)
+    :unary
+  )
 
   attr_reader :processed_count
 
-  def initialize expression_resolver
+  def initialize(expression_resolver)
     @resolver = expression_resolver
   end
 
   def evaluate(expressions)
+    @dropped_expression = nil
     @processed_count = 0
     @index = Node.new(0, 0, "And", 0, true, false, 0, nil)
     @groups = [@index]
@@ -33,10 +34,11 @@ class Sparkql::Evaluator
       adjust_expression_for_dropped_field(expression)
       check_for_good_ors(expression)
       next if skip?(expression)
+
       evaluate_expression(expression)
     end
     cleanup
-    return @index[:match]
+    @index[:match]
   end
 
   private
@@ -58,9 +60,10 @@ class Sparkql::Evaluator
   # 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
+    @processed_count += 1
     evaluate_node(expression, @resolver.resolve(expression))
   end
+
   def evaluate_node(node, result)
     if result == :drop
       @dropped_expression = node
@@ -73,7 +76,7 @@ class Sparkql::Evaluator
        (node[:conjunction_level] == node[:level] ||
         node[:conjunction_level] == @index[:level])
       @index[:match] = !result if @index[:match]
-    elsif node[:conjunction] == 'And' || @index[:expressions] == 0
+    elsif node[:conjunction] == 'And' || (@index[:expressions]).zero?
       @index[:match] = result if @index[:match]
     elsif node[:conjunction] == 'Or' && result
       @index[:match] = result
@@ -97,7 +100,7 @@ class Sparkql::Evaluator
           end
         end
       end
-      if !good_index.nil? && good_index[:expressions] > 0 && good_index[:match]
+      if !good_index.nil? && (good_index[:expressions]).positive? && good_index[:match]
         good_index[:good_ors] = true
       end
     end
@@ -112,8 +115,8 @@ class Sparkql::Evaluator
 
   def new_group(expression)
     Node.new(expression[:level], expression[:block_group],
-      expression[:conjunction], expression[:conjunction_level],
-      true, false, 0, nil)
+             expression[:conjunction], expression[:conjunction_level],
+             true, false, 0, nil)
   end
 
   # When the last expression was dropped, we need to repair the filter by
@@ -125,6 +128,7 @@ class Sparkql::Evaluator
       expression[:conjunction] = @dropped_expression[:conjunction]
       expression[:conjunction_level] = @dropped_expression[:conjunction_level]
     end
+
     @dropped_expression = nil
   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

data/lib/sparkql/expression_state.rb

@@ -1,23 +1,21 @@
-# Custom fields need to add a table join to the customfieldsearch table when AND'd together, 
+# Custom fields need to add a table join to the customfieldsearch table when AND'd together,
 # but not when they are OR'd or nested. This class maintains the state for all custom field expressions
 # lets the parser know when to do either.
 class Sparkql::ExpressionState
-  
   def initialize
-    @expressions = {0=>[]}
+    @expressions = { 0 => [] }
     @last_conjunction = "And" # always start with a join
     @block_group = 0
   end
-  
+
   def push(expression)
     @block_group = expression[:block_group]
-    @expressions[@block_group] ||= [] 
+    @expressions[@block_group] ||= []
     @expressions[@block_group] << expression
     @last_conjunction = expression[:conjunction]
   end
-  
+
   def needs_join?
-    return @expressions[@block_group].size == 1 || ["Not", "And"].include?(@last_conjunction)
+    @expressions[@block_group].size == 1 || %w[Not And].include?(@last_conjunction)
   end
-  
-end
+end

data/lib/sparkql/function_resolver.rb

@@ -225,14 +225,19 @@ module Sparkql
       }
     }.freeze
 
+    def self.lookup(function_name)
+      SUPPORTED_FUNCTIONS[function_name.to_sym]
+    end
+
     # Construct a resolver instance for a function
     # name: function name (String)
     # args: array of literal hashes of the format {:type=><literal_type>, :value=><escaped_literal_value>}.
     #       Empty arry for functions that have no arguments.
-    def initialize(name, args)
+    def initialize(name, args, options = {})
       @name = name
       @args = args
       @errors = []
+      @current_timestamp = options[:current_timestamp]
     end
 
     # Validate the function instance prior to calling it. All validation failures will show up in the
@@ -541,18 +546,16 @@ module Sparkql
       today += weeks * 7
 
       # Now iterate on the remaining weekdays
-      remaining.times do |i|
+      remaining.times do |_i|
         today += direction
-        while today.saturday? || today.sunday?
-          today += direction
-        end
+        today += direction while today.saturday? || today.sunday?
       end
 
       # If we end on the weekend, bump accordingly
       while today.saturday? || today.sunday?
         # If we start and end on the weekend, wind things back to the next
         # appropriate weekday.
-        if weekend_start && remaining == 0
+        if weekend_start && remaining.zero?
           today -= direction
         else
           today += direction
@@ -637,7 +640,8 @@ module Sparkql
     end
 
     def months(num_months)
-      d = current_timestamp >> num_months
+      # DateTime usage. There's a better means to do this with Time via rails
+      d = (current_timestamp.to_datetime >> num_months).to_time
       {
         type: :date,
         value: d.strftime(STRFTIME_DATE_FORMAT)
@@ -645,7 +649,8 @@ module Sparkql
     end
 
     def years(num_years)
-      d = current_timestamp >> (num_years * 12)
+      # DateTime usage. There's a better means to do this with Time via rails
+      d = (current_timestamp.to_datetime >> (num_years * 12)).to_time
       {
         type: :date,
         value: d.strftime(STRFTIME_DATE_FORMAT)
@@ -832,11 +837,11 @@ module Sparkql
     end
 
     def current_time
-      current_timestamp.to_time
+      current_timestamp
     end
 
     def current_timestamp
-      @current_timestamp ||= DateTime.now
+      @current_timestamp ||= Time.now
     end
 
     private

data/lib/sparkql/geo/record_circle.rb

@@ -1,7 +1,7 @@
 module Sparkql
   module Geo
     class RecordRadius
-      RECORD_ID_REGEX = /\A[0-9]{26}\z/
+      RECORD_ID_REGEX = /\A[0-9]{26}\z/.freeze
 
       attr_accessor :record_id, :radius