sparkql 1.2.8 → 1.3.1

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
 

data/lib/sparkql/lexer.rb

@@ -2,9 +2,9 @@ require 'strscan'
 
 class Sparkql::Lexer < StringScanner
   include Sparkql::Token
-  
+
   attr_accessor :level, :block_group_identifier
-  
+
   attr_reader :last_field, :current_token_value, :token_index
 
   def initialize(str)
@@ -14,51 +14,50 @@ class Sparkql::Lexer < StringScanner
     @block_group_identifier = 0
     @expression_count = 0
   end
-  
+
   # Lookup the next matching token
   def shift
     @token_index = self.pos
 
-    token = case
-      when @current_token_value = scan(SPACE)
-        [:SPACE, @current_token_value]
-      when @current_token_value = scan(LPAREN)
-        levelup
-        [:LPAREN, @current_token_value]
-      when @current_token_value = scan(RPAREN)
-        # leveldown: do this after parsing group
-        [:RPAREN, @current_token_value]
-      when @current_token_value = scan(/\,/)
-        [:COMMA,@current_token_value]
-      when @current_token_value = scan(NULL)
-        literal :NULL, "NULL"
-      when @current_token_value = scan(STANDARD_FIELD)
-        check_standard_fields(@current_token_value)
-      when @current_token_value = scan(DATETIME)
-        literal :DATETIME, @current_token_value
-      when @current_token_value = scan(DATE)
-        literal :DATE, @current_token_value
-      when @current_token_value = scan(TIME)
-        literal :TIME, @current_token_value
-      when @current_token_value = scan(DECIMAL)
-        literal :DECIMAL, @current_token_value
-      when @current_token_value = scan(INTEGER)
-        literal :INTEGER, @current_token_value
-      when @current_token_value = scan(/\-/)
-        [:UMINUS, @current_token_value]
-      when @current_token_value = scan(CHARACTER)
-        literal :CHARACTER, @current_token_value
-      when @current_token_value = scan(BOOLEAN)
-        literal :BOOLEAN, @current_token_value
-      when @current_token_value = scan(KEYWORD)
-        check_keywords(@current_token_value)
-      when @current_token_value = scan(CUSTOM_FIELD)
-        [:CUSTOM_FIELD,@current_token_value]
-      when eos?
-        [false, false] # end of file, \Z don't work with StringScanner
-      else
-        [:UNKNOWN, "ERROR: '#{self.string}'"]
-    end
+    token = if (@current_token_value = scan(SPACE))
+              [:SPACE, @current_token_value]
+            elsif (@current_token_value = scan(LPAREN))
+              levelup
+              [:LPAREN, @current_token_value]
+            elsif (@current_token_value = scan(RPAREN))
+              # leveldown: do this after parsing group
+              [:RPAREN, @current_token_value]
+            elsif (@current_token_value = scan(/,/))
+              [:COMMA, @current_token_value]
+            elsif (@current_token_value = scan(NULL))
+              literal :NULL, "NULL"
+            elsif (@current_token_value = scan(STANDARD_FIELD))
+              check_standard_fields(@current_token_value)
+            elsif (@current_token_value = scan(DATETIME))
+              literal :DATETIME, @current_token_value
+            elsif (@current_token_value = scan(DATE))
+              literal :DATE, @current_token_value
+            elsif (@current_token_value = scan(TIME))
+              literal :TIME, @current_token_value
+            elsif (@current_token_value = scan(DECIMAL))
+              literal :DECIMAL, @current_token_value
+            elsif (@current_token_value = scan(INTEGER))
+              literal :INTEGER, @current_token_value
+            elsif (@current_token_value = scan(/-/))
+              [:UMINUS, @current_token_value]
+            elsif (@current_token_value = scan(CHARACTER))
+              literal :CHARACTER, @current_token_value
+            elsif (@current_token_value = scan(BOOLEAN))
+              literal :BOOLEAN, @current_token_value
+            elsif (@current_token_value = scan(KEYWORD))
+              check_keywords(@current_token_value)
+            elsif (@current_token_value = scan(CUSTOM_FIELD))
+              [:CUSTOM_FIELD, @current_token_value]
+            elsif eos?
+              [false, false] # end of file, \Z don't work with StringScanner
+            else
+              [:UNKNOWN, "ERROR: '#{self.string}'"]
+            end
 
     token.freeze
   end
@@ -66,13 +65,13 @@ class Sparkql::Lexer < StringScanner
   def check_reserved_words(value)
     u_value = value.capitalize
     if OPERATORS.include?(u_value)
-      [:OPERATOR,u_value]
+      [:OPERATOR, u_value]
     elsif RANGE_OPERATOR == u_value
-      [:RANGE_OPERATOR,u_value]
+      [:RANGE_OPERATOR, u_value]
     elsif CONJUNCTIONS.include?(u_value)
-      [:CONJUNCTION,u_value]
+      [:CONJUNCTION, u_value]
     elsif UNARY_CONJUNCTIONS.include?(u_value)
-      [:UNARY_CONJUNCTION,u_value]
+      [:UNARY_CONJUNCTION, u_value]
     elsif ADD == u_value
       [:ADD, u_value]
     elsif SUB == u_value
@@ -87,12 +86,12 @@ class Sparkql::Lexer < StringScanner
       [:UNKNOWN, "ERROR: '#{self.string}'"]
     end
   end
-  
+
   def check_standard_fields(value)
     result = check_reserved_words(value)
     if result.first == :UNKNOWN
       @last_field = value
-      result = [:STANDARD_FIELD,value]
+      result = [:STANDARD_FIELD, value]
     end
     result
   end
@@ -100,26 +99,25 @@ class Sparkql::Lexer < StringScanner
   def check_keywords(value)
     result = check_reserved_words(value)
     if result.first == :UNKNOWN
-      result = [:KEYWORD,value]
+      result = [:KEYWORD, value]
     end
     result
   end
-  
+
   def levelup
     @level += 1
     @block_group_identifier += 1
   end
-  
+
   def leveldown
     @level -= 1
   end
-  
+
   def literal(symbol, value)
     node = {
-      :type => symbol.to_s.downcase.to_sym,
-      :value => value
+      type: symbol.to_s.downcase.to_sym,
+      value: value
     }
     [symbol, node]
   end
-  
 end