sparkql 1.2.8 → 1.3.0

data/lib/sparkql/parser_compatibility.rb

@@ -1,6 +1,5 @@
 # Required interface for existing parser implementations
 module Sparkql::ParserCompatibility
-
   MAXIMUM_MULTIPLE_VALUES = 200
   MAXIMUM_EXPRESSIONS = 75
   MAXIMUM_LEVEL_DEPTH = 2
@@ -9,72 +8,71 @@ module Sparkql::ParserCompatibility
   # Ordered by precedence.
   FILTER_VALUES = [
     {
-      :type => :datetime,
-      :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
+      type: :datetime,
+      operators: Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
     },
     {
-      :type => :date,
-      :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
+      type: :date,
+      operators: Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
     },
     {
-      :type => :time,
-      :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
+      type: :time,
+      operators: Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
     },
     {
-      :type => :character,
-      :multiple => /^'([^'\\]*(\\.[^'\\]*)*)'/,
-      :operators => Sparkql::Token::EQUALITY_OPERATORS
+      type: :character,
+      multiple: /^'([^'\\]*(\\.[^'\\]*)*)'/,
+      operators: Sparkql::Token::EQUALITY_OPERATORS
     },
     {
-      :type => :integer,
-      :multiple => /^\-?[0-9]+/,
-      :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
+      type: :integer,
+      multiple: /^-?[0-9]+/,
+      operators: Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
     },
     {
-      :type => :decimal,
-      :multiple => /^\-?[0-9]+\.[0-9]+/,
-      :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
+      type: :decimal,
+      multiple: /^-?[0-9]+\.[0-9]+/,
+      operators: Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
     },
     {
-      :type => :shape,
-      :operators => Sparkql::Token::EQUALITY_OPERATORS
+      type: :shape,
+      operators: Sparkql::Token::EQUALITY_OPERATORS
     },
     {
-      :type => :boolean,
-      :operators => Sparkql::Token::EQUALITY_OPERATORS
+      type: :boolean,
+      operators: Sparkql::Token::EQUALITY_OPERATORS
     },
     {
-      :type => :null,
-      :operators => Sparkql::Token::EQUALITY_OPERATORS
+      type: :null,
+      operators: Sparkql::Token::EQUALITY_OPERATORS
     },
     {
-      :type => :function,
-      :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
-    },
-  ]
+      type: :function,
+      operators: Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
+    }
+  ].freeze
 
-  OPERATORS_SUPPORTING_MULTIPLES = ["Eq","Ne"]
+  OPERATORS_SUPPORTING_MULTIPLES = %w[Eq Ne].freeze
 
   # To be implemented by child class.
   # Shall return a valid query string for the respective database,
   # or nil if the source could not be processed.  It may be possible to return a valid
   # SQL string AND have errors ( as checked by errors? ), but this will be left
   # to the discretion of the child class.
-  def compile( source, mapper )
-   raise NotImplementedError
+  def compile(source, mapper)
+    raise NotImplementedError
   end
 
   # Returns a list of expressions tokenized in the following format:
   # [{ :field => IdentifierName, :operator => "Eq", :value => "'Fargo'", :type => :character, :conjunction => "And" }]
   # This step will set errors if source is not syntactically correct.
-  def tokenize( source )
+  def tokenize(source)
     raise ArgumentError, "You must supply a source string to tokenize!" unless source.is_a?(String)
 
     # Reset the parser error stack
     @errors = []
 
-    expressions = self.parse(source)
-    expressions
+    self.parse(source)
   end
 
   # Returns an array of errors.  This is an array of ParserError objects
@@ -93,32 +91,36 @@ module Sparkql::ParserCompatibility
   def errors?
     process_errors.errors?
   end
+
   def fatal_errors?
     process_errors.fatal_errors?
   end
+
   def dropped_errors?
     process_errors.dropped_errors?
   end
+
   def recovered_errors?
     process_errors.recovered_errors?
   end
 
-  def escape_value_list( expression )
+  def escape_value_list(expression)
     final_list = []
-    expression[:value].each do | value |
+    expression[:value].each do |value|
       new_exp = {
-        :value => value,
-        :type => expression[:type]
+        value: value,
+        type: expression[:type]
       }
       final_list << escape_value(new_exp)
     end
     expression[:value] = final_list
   end
 
-  def escape_value( expression )
+  def escape_value(expression)
     if expression[:value].is_a? Array
-      return escape_value_list( expression )
+      return escape_value_list(expression)
     end
+
     case expression[:type]
     when :character
       return character_escape(expression[:value])
@@ -142,15 +144,15 @@ module Sparkql::ParserCompatibility
 
   # processes escape characters for a given string.  May be overridden by
   # child classes.
-  def character_escape( string )
-    string.gsub(/^\'/,'').gsub(/\'$/,'').gsub(/\\'/, "'")
+  def character_escape(string)
+    string.gsub(/^'/, '').gsub(/'$/, '').gsub(/\\'/, "'")
   end
 
-  def integer_escape( string )
+  def integer_escape(string)
     string.to_i
   end
 
-  def decimal_escape( string )
+  def decimal_escape(string)
     string.to_f
   end
 
@@ -158,20 +160,29 @@ module Sparkql::ParserCompatibility
     Date.parse(string)
   end
 
+  # datetime may have timezone info. Given that, we should honor it it when
+  # present or setting an appropriate default when not. Either way, we should
+  # convert to local appropriate for the parser when we're done.
+  #
+  # DateTime in ruby is deprecated as of ruby 3.0. We've switched to the Time
+  # class to be future compatible. The :time type in sparkql != a ruby Time
+  # instance
   def datetime_escape(string)
-    DateTime.parse(string)
+    Time.parse(string)
   end
 
+  # Per the lexer, times don't have any timezone info. When parsing, pick the
+  # proper offset to set things at.
   def time_escape(string)
-    DateTime.parse(string)
+    Time.parse("#{string}#{offset}")
   end
 
   def boolean_escape(string)
-    "true" == string
+    string == "true"
   end
 
   # Returns the rule hash for a given type
-  def rules_for_type( type )
+  def rules_for_type(type)
     FILTER_VALUES.each do |rule|
       return rule if rule[:type] == type
     end
@@ -179,8 +190,8 @@ module Sparkql::ParserCompatibility
   end
 
   # true if a given type supports multiple values
-  def supports_multiple?( type )
-    rules_for_type(type).include?( :multiple )
+  def supports_multiple?(type)
+    rules_for_type(type).include?(:multiple)
   end
 
   # Maximum supported nesting level for the parser filters
@@ -202,21 +213,20 @@ module Sparkql::ParserCompatibility
 
   private
 
-  def tokenizer_error( error_hash )
-
+  def tokenizer_error(error_hash)
     if @lexer
       error_hash[:token_index] = @lexer.token_index
     end
 
-    self.errors << Sparkql::ParserError.new( error_hash )
+    self.errors << Sparkql::ParserError.new(error_hash)
   end
-  alias :compile_error :tokenizer_error
+  alias compile_error tokenizer_error
 
   # Checks the type of an expression with what is expected.
   def check_type!(expression, expected, supports_nulls = true)
     if (expected == expression[:type] && !expression.key?(:field_manipulations)) ||
-        (expression.key?(:field_manipulations) && check_function_type?(expression, expected)) ||
-      (supports_nulls && expression[:type] == :null)
+       (expression.key?(:field_manipulations) && check_function_type?(expression, expected)) ||
+       (supports_nulls && expression[:type] == :null)
       return true
     # If the field will be passed into a function,
     # check the type of the return value of the function
@@ -235,7 +245,7 @@ module Sparkql::ParserCompatibility
       expression[:type] = :date
       expression[:cast] = :datetime
       if multiple_values?(expression[:value])
-        expression[:value].map!{ |val| coerce_datetime val }
+        expression[:value].map! { |val| coerce_datetime val }
       else
         expression[:value] = coerce_datetime expression[:value]
       end
@@ -245,14 +255,15 @@ module Sparkql::ParserCompatibility
       expression[:cast] = :integer
       return true
     end
+
     type_error(expression, expected)
     false
   end
 
-  def type_error( expression, expected )
-      compile_error(:token => expression[:field], :expression => expression,
-            :message => "expected #{expected} but found #{expression[:type]}",
-            :status => :fatal )
+  def type_error(expression, expected)
+    compile_error(token: expression[:field], expression: expression,
+                  message: "expected #{expected} but found #{expression[:type]}",
+                  status: :fatal)
   end
 
   # If a function is being applied to a field, we check that the return type of
@@ -263,15 +274,17 @@ module Sparkql::ParserCompatibility
   end
 
   def validate_manipulation_types(field_manipulations, expected)
-    if field_manipulations[:type] == :function
-      function = Sparkql::FunctionResolver::SUPPORTED_FUNCTIONS[field_manipulations[:function_name].to_sym]
-      return false if function.nil?
+    case field_manipulations[:type]
+    when :function
+      return false unless supported_function?(field_manipulations[:function_name])
+
+      function = lookup_function(field_manipulations[:function_name])
       field_manipulations[:args].each_with_index do |arg, index|
-        if arg[:type] == :field
-          return false unless function[:args][index].include?(:field)
+        if arg[:type] == :field && !function[:args][index].include?(:field)
+          return false
         end
       end
-    elsif field_manipulations[:type] == :arithmetic
+    when :arithmetic
       lhs = field_manipulations[:lhs]
       return false unless validate_side(lhs, expected)
 
@@ -285,31 +298,34 @@ module Sparkql::ParserCompatibility
     if side[:type] == :arithmetic
       return validate_manipulation_types(side, expected)
     elsif side[:type] == :field
-      return false unless [:decimal, :integer].include?(expected)
+      return false unless %i[decimal integer].include?(expected)
     elsif side[:type] == :function
-      return false unless [:decimal, :integer].include?(side[:return_type])
-    elsif ![:decimal, :integer].include?(side[:type])
+      return false unless %i[decimal integer].include?(side[:return_type])
+    elsif !%i[decimal integer].include?(side[:type])
       return false
     end
+
     true
   end
 
   # Builds the correct operator based on the type and the value.
   # default should be the operator provided in the actual filter string
-  def get_operator(expression, default )
+  def get_operator(expression, default)
     f = rules_for_type(expression[:type])
     if f[:operators].include?(default)
       if f[:multiple] && range?(expression[:value]) && default == 'Bt'
         return "Bt"
       elsif f[:multiple] && multiple_values?(expression[:value])
         return nil unless operator_supports_multiples?(default)
+
         return default == "Ne" ? "Not In" : "In"
       elsif default == "Ne"
         return "Not Eq"
       end
-      return default
+
+      default
     else
-      return nil
+      nil
     end
   end
 
@@ -325,12 +341,17 @@ module Sparkql::ParserCompatibility
     OPERATORS_SUPPORTING_MULTIPLES.include?(operator)
   end
 
-  def coerce_datetime datetime
-    if datestr = datetime.match(/^(\d{4}-\d{2}-\d{2})/)
-      datestr[0]
+  # Datetime coercion to date factors in the current time zone when selecting a
+  # date.
+  def coerce_datetime(datetime_string)
+    case datetime_string
+    when /^(\d{4}-\d{2}-\d{2})$/
+      datetime_string
+    when /^(\d{4}-\d{2}-\d{2})/
+      datetime = datetime_escape(datetime_string)
+      datetime.strftime(Sparkql::FunctionResolver::STRFTIME_DATE_FORMAT)
     else
-      datetime
+      datetime_string
     end
   end
-
 end