sparkql 1.2.2 → 1.2.7

data/lib/sparkql/parser.y

@@ -98,6 +98,8 @@ rule
     | field_arithmetic_expression MUL field_arithmetic_expression { result = tokenize_arithmetic(val[0], val[1], val[2]) }
     | field_arithmetic_expression DIV field_arithmetic_expression { result = tokenize_arithmetic(val[0], val[1], val[2]) }
     | field_arithmetic_expression MOD field_arithmetic_expression { result = tokenize_arithmetic(val[0], val[1], val[2]) }
+    | LPAREN field_arithmetic_expression RPAREN { result = tokenize_arithmetic_group(val[1]) }
+    | UMINUS field_arithmetic_expression { result = tokenize_arithmetic_negation(val[1]) }
     | literals
     | field_function_expression
     ;
@@ -117,6 +119,8 @@ rule
     : arithmetic_condition
     | literal_list { result = tokenize_list(val[0]) }
     | literal
+    | LPAREN condition RPAREN { result = group_fold(val[1]) }
+    | UMINUS condition { result = tokenize_literal_negation(val[1]) }
     ;
 
   arithmetic_condition
@@ -194,8 +198,6 @@ rule
     : INTEGER
     | DECIMAL
     | CHARACTER
-    | LPAREN literals RPAREN { result = val[1] }
-    | UMINUS literals { result = tokenize_literal_negation(val[1]) }
     ;
 
 ##### Literal

data/lib/sparkql/parser_compatibility.rb

@@ -85,7 +85,7 @@ module Sparkql::ParserCompatibility
 
   # Delegator for methods to process the error list.
   def process_errors
-    Sparkql::ErrorsProcessor.new(@errors)
+    Sparkql::ErrorsProcessor.new(errors)
   end
 
   # delegate :errors?, :fatal_errors?, :dropped_errors?, :recovered_errors?, :to => :process_errors
@@ -161,7 +161,7 @@ module Sparkql::ParserCompatibility
   def datetime_escape(string)
     DateTime.parse(string)
   end
-  
+
   def time_escape(string)
     DateTime.parse(string)
   end
@@ -214,7 +214,8 @@ module Sparkql::ParserCompatibility
 
   # Checks the type of an expression with what is expected.
   def check_type!(expression, expected, supports_nulls = true)
-    if expected == expression[:type] || check_function_type?(expression, expected) ||
+    if (expected == expression[:type] && !expression.key?(:field_manipulations)) ||
+        (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,
@@ -230,7 +231,7 @@ module Sparkql::ParserCompatibility
       expression[:type] = :datetime
       expression[:cast] = :date
       return true
-    elsif expected == :date && expression[:type] == :datetime 
+    elsif expected == :date && expression[:type] == :datetime
       expression[:type] = :date
       expression[:cast] = :datetime
       if multiple_values?(expression[:value])
@@ -253,26 +254,44 @@ module Sparkql::ParserCompatibility
             :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
   # the function matches what is expected, and that the function supports the
   # field type as the first argument.
   def check_function_type?(expression, expected)
-    return false unless expression.key?(:field_manipulations) && expression[:field_manipulations][:return_type] == expression[:type]
-    # Lookup the function arguments
-    function = Sparkql::FunctionResolver::SUPPORTED_FUNCTIONS[deepest_function(expression[:field_manipulations])[:function_name].to_sym]
-    return false if function.nil?
-
-    Array(function[:args].first).include?(expected)
+    validate_manipulation_types(expression[:field_manipulations], expected)
   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?
+      field_manipulations[:args].each_with_index do |arg, index|
+        if arg[:type] == :field
+          return false unless function[:args][index].include?(:field)
+        end
+      end
+    elsif field_manipulations[:type] == :arithmetic
+      lhs = field_manipulations[:lhs]
+      return false unless validate_side(lhs, expected)
 
-  def deepest_function(function)
-    if function[:args].first[:type] == :function
-      deepest_function(function[:args].first)
-    else
-      function
+      rhs = field_manipulations[:rhs]
+      return false unless rhs.nil? || validate_side(rhs, expected)
+    end
+    true
+  end
+
+  def validate_side(side, expected)
+    if side[:type] == :arithmetic
+      return validate_manipulation_types(side, expected)
+    elsif side[:type] == :field
+      return false unless [: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
     end
+    true
   end
 
   # Builds the correct operator based on the type and the value.
@@ -305,7 +324,7 @@ module Sparkql::ParserCompatibility
   def operator_supports_multiples?(operator)
     OPERATORS_SUPPORTING_MULTIPLES.include?(operator)
   end
-  
+
   def coerce_datetime datetime
     if datestr = datetime.match(/^(\d{4}-\d{2}-\d{2})/)
       datestr[0]

data/lib/sparkql/parser_tools.rb

@@ -1,10 +1,14 @@
 # This is the guts of the parser internals and is mixed into the parser for organization.
+require 'bigdecimal'
+
 module Sparkql::ParserTools
 
   # Coercible types from highest precision to lowest
   DATE_TYPES = [:datetime, :date]
   NUMBER_TYPES = [:decimal, :integer]
   ARITHMETIC_TYPES = [:decimal, :integer, :field, :arithmetic]
+  GROUP = 'Group'.freeze
+  NEGATION = 'Negation'.freeze
 
   def parse(str)
     @lexer = Sparkql::Lexer.new(str)
@@ -24,24 +28,16 @@ module Sparkql::ParserTools
   end
 
   def arithmetic_field(nested_representation)
-    lhs = nested_representation[:lhs]
-    rhs = nested_representation[:rhs]
-
-    if lhs[:type] == :field
-      lhs[:value]
-    elsif rhs[:type] == :field
-      rhs[:value]
-    elsif lhs.key?(:field)
-      lhs[:field]
-    elsif rhs.key?(:field)
-      rhs[:field]
-    elsif lhs[:type] == :arithmetic
-      arithmetic_field(lhs)
-    elsif rhs[:type] == :arithmetic
-      arithmetic_field(rhs)
-    else
-      nil
-    end
+    return if nested_representation.nil?
+
+    return nested_representation[:value] if nested_representation[:type] == :field
+    return nested_representation[:field] if nested_representation.key?(:field)
+
+    field = arithmetic_field(nested_representation[:lhs])
+    return field unless field.nil?
+
+    field = arithmetic_field(nested_representation[:rhs])
+    return field unless field.nil?
   end
 
   def no_field_error(field, operator)
@@ -129,6 +125,26 @@ module Sparkql::ParserTools
     expressions
   end
 
+  def tokenize_arithmetic_group(lhs)
+    @lexer.leveldown
+    @lexer.block_group_identifier -= 1
+    lhs = {type: :field, value: lhs} if lhs.is_a?(String)
+    {
+      type: :arithmetic,
+      op: GROUP,
+      lhs: lhs
+    }
+  end
+
+  def tokenize_arithmetic_negation(lhs)
+    lhs = {type: :field, value: lhs} if lhs.is_a?(String)
+    {
+      type: :arithmetic,
+      op: NEGATION,
+      lhs: lhs
+    }
+  end
+
   def tokenize_list(list)
     return if list.nil?
     validate_multiple_values list[:value]
@@ -245,22 +261,31 @@ module Sparkql::ParserTools
     true
   end
 
+  def group_fold(exp)
+    @lexer.leveldown
+    @lexer.block_group_identifier -= 1
+    exp
+  end
+
   def add_fold(n1, n2)
     return if arithmetic_error?(n1) || arithmetic_error?(n2)
 
-    { type: arithmetic_type(n1, n2), value: (escape_value(n1) + escape_value(n2)).to_s }
+    value = escape_arithmetic_value(n1) + escape_arithmetic_value(n2)
+    { type: arithmetic_type(n1, n2), value: unescape_arithmetic(value) }
   end
 
   def sub_fold(n1, n2)
     return if arithmetic_error?(n1) || arithmetic_error?(n2)
 
-    { type: arithmetic_type(n1, n2), value: (escape_value(n1) - escape_value(n2)).to_s }
+    value = escape_arithmetic_value(n1) - escape_arithmetic_value(n2)
+    { type: arithmetic_type(n1, n2), value: unescape_arithmetic(value) }
   end
 
   def mul_fold(n1, n2)
     return if arithmetic_error?(n1) || arithmetic_error?(n2)
 
-    { type: arithmetic_type(n1, n2), value: (escape_value(n1) * escape_value(n2)).to_s }
+    value = escape_arithmetic_value(n1) * escape_arithmetic_value(n2)
+    { type: arithmetic_type(n1, n2), value: unescape_arithmetic(value) }
   end
 
   def div_fold(n1, n2)
@@ -268,7 +293,8 @@ module Sparkql::ParserTools
       arithmetic_error?(n2) ||
       zero_error?(n2)
 
-    { type: arithmetic_type(n1, n2), value: (escape_value(n1) / escape_value(n2)).to_s }
+    value = escape_arithmetic_value(n1) / escape_arithmetic_value(n2)
+    { type: arithmetic_type(n1, n2), value: unescape_arithmetic(value) }
   end
 
   def mod_fold(n1, n2)
@@ -276,7 +302,8 @@ module Sparkql::ParserTools
       arithmetic_error?(n2) ||
       zero_error?(n2)
 
-    { type: arithmetic_type(n1, n2), value: (escape_value(n1) % escape_value(n2)).to_s }
+    value = escape_arithmetic_value(n1) % escape_arithmetic_value(n2)
+    { type: arithmetic_type(n1, n2), value: unescape_arithmetic(value) }
   end
 
   def arithmetic_type(num1, num2)
@@ -287,6 +314,23 @@ module Sparkql::ParserTools
     end
   end
 
+  def escape_arithmetic_value(expression)
+    case expression[:type]
+    when :decimal
+      BigDecimal.new(expression[:value])
+    else
+      escape_value(expression)
+    end
+  end
+
+  def unescape_arithmetic(value)
+    if value.is_a?(BigDecimal)
+      value.round(20).to_s('F')
+    else
+      value.to_s
+    end
+  end
+
   def zero_error?(number)
     return unless escape_value(number) == 0
 

data/sparkql.gemspec

@@ -1,30 +1,32 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "sparkql/version"
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'sparkql/version'
 
 Gem::Specification.new do |s|
-  s.name        = "sparkql"
+  s.name        = 'sparkql'
   s.version     = Sparkql::VERSION
-  s.authors     = ["Wade McEwen"]
-  s.email       = ["wade@fbsdata.com"]
-  s.homepage    = ""
-  s.summary     = %q{API Parser engine for filter searching}
-  s.description = %q{Specification and base implementation of the Spark API parsing system.}
+  s.authors     = ['Wade McEwen']
+  s.email       = ['wade@fbsdata.com']
+  s.homepage    = ''
+  s.summary     = 'API Parser engine for filter searching'
+  s.description = 'Specification and base implementation of the Spark API parsing system.'
+
+  s.rubyforge_project = 'sparkql'
 
-  s.rubyforge_project = "sparkql"
-  
   s.license       = 'Apache 2.0'
- 
+
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 2.3'
 
   s.add_dependency             'georuby', '~> 2.0'
+  s.add_development_dependency 'ci_reporter', '~> 1.6'
+  s.add_development_dependency 'mocha', '~> 0.12.0'
   s.add_development_dependency 'racc', '~> 1.4.8'
   s.add_development_dependency 'rake', '~> 0.9.2'
   s.add_development_dependency 'test-unit', '~> 2.1.0'
-  s.add_development_dependency 'ci_reporter', '~> 1.6'
-  s.add_development_dependency 'mocha', '~> 0.12.0'
-
 end

data/test/unit/function_resolver_test.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'sparkql/geo'
 
 class FunctionResolverTest < Test::Unit::TestCase
   include Sparkql
-  
-  EXAMPLE_DATE = DateTime.parse("2013-07-26T10:22:15.422804")
 
-  test "function parameters and name preserved" do
-    f = FunctionResolver.new('radius', [{:type => :character, 
-          :value => "35.12 -68.33"},{:type => :decimal, :value => 1.0}])
+  EXAMPLE_DATE = DateTime.parse('2013-07-26T10:22:15.422804')
+
+  test 'function parameters and name preserved' do
+    f = FunctionResolver.new('radius', [{ type: :character,
+                                          value: '35.12 -68.33' }, { type: :decimal, value: 1.0 }])
     value = f.call
     assert_equal 'radius', value[:function_name]
-    assert_equal(["35.12 -68.33", 1.0], value[:function_parameters])
+    assert_equal(['35.12 -68.33', 1.0], value[:function_parameters])
   end
 
-  test "round(float)" do
-    f = FunctionResolver.new('round', [{:type => :decimal, :value => 0.5}])
+  test 'round(float)' do
+    f = FunctionResolver.new('round', [{ type: :decimal, value: 0.5 }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -23,22 +25,22 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '1', value[:value]
   end
 
-  test "round(Field)" do
-    f = FunctionResolver.new('round', [{:type => :field, :value => 'ListPrice'}])
+  test 'round(Field)' do
+    f = FunctionResolver.new('round', [{ type: :field, value: 'ListPrice' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
 
     assert_equal :function, value[:type]
     assert_equal 'round', value[:value]
-    assert_equal "ListPrice", value[:args].first[:value]
+    assert_equal 'ListPrice', value[:args].first[:value]
   end
 
-  test "substring character one index" do
+  test 'substring character one index' do
     f = FunctionResolver.new('substring', [
-      {:type => :character, :value => 'ListPrice'},
-      {:type => :integer, :value => 1}
-    ])
+                               { type: :character, value: 'ListPrice' },
+                               { type: :integer, value: 1 }
+                             ])
 
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
@@ -48,26 +50,26 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal 'istPrice', value[:value]
   end
 
-  test "substring character two indexes" do
+  test 'substring character two indexes' do
     f = FunctionResolver.new('substring', [
-      {:type => :character, :value => 'alfb'},
-      {:type => :integer, :value => 1},
-      {:type => :integer, :value => 2}
-    ])
+                               { type: :character, value: 'alfb' },
+                               { type: :integer, value: 1 },
+                               { type: :integer, value: 2 }
+                             ])
 
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
 
     assert_equal :character, value[:type]
-    assert_equal "lf", value[:value]
+    assert_equal 'lf', value[:value]
   end
 
-  test "substring character large first index" do
+  test 'substring character large first index' do
     f = FunctionResolver.new('substring', [
-      {:type => :character, :value => 'ListPrice'},
-      {:type => :integer, :value => 10}
-    ])
+                               { type: :character, value: 'ListPrice' },
+                               { type: :integer, value: 10 }
+                             ])
 
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
@@ -77,11 +79,11 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '', value[:value]
   end
 
-  test "substring field one index" do
+  test 'substring field one index' do
     f = FunctionResolver.new('substring', [
-      {:type => :field, :value => 'ListPrice'},
-      {:type => :integer, :value => 1}
-    ])
+                               { type: :field, value: 'ListPrice' },
+                               { type: :integer, value: 1 }
+                             ])
 
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
@@ -89,16 +91,16 @@ class FunctionResolverTest < Test::Unit::TestCase
 
     assert_equal :function, value[:type]
     assert_equal 'substring', value[:value]
-    assert_equal "ListPrice", value[:args].first[:value]
+    assert_equal 'ListPrice', value[:args].first[:value]
     assert_equal 2, value[:args].size
   end
 
-  test "substring field two indexes" do
+  test 'substring field two indexes' do
     f = FunctionResolver.new('substring', [
-      {:type => :field, :value => 'ListPrice'},
-      {:type => :integer, :value => 1},
-      {:type => :integer, :value => 2}
-    ])
+                               { type: :field, value: 'ListPrice' },
+                               { type: :integer, value: 1 },
+                               { type: :integer, value: 2 }
+                             ])
 
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
@@ -106,28 +108,28 @@ class FunctionResolverTest < Test::Unit::TestCase
 
     assert_equal :function, value[:type]
     assert_equal 'substring', value[:value]
-    assert_equal "ListPrice", value[:args].first[:value]
+    assert_equal 'ListPrice', value[:args].first[:value]
     assert_equal 2, value[:args].last[:value]
   end
 
-  test "substring with negative M is a parse error" do
+  test 'substring with negative M is a parse error' do
     f = FunctionResolver.new('substring', [
-      {:type => :field, :value => 'ListPrice'},
-      {:type => :integer, :value => 1},
-      {:type => :integer, :value => -5}
-    ])
+                               { type: :field, value: 'ListPrice' },
+                               { type: :integer, value: 1 },
+                               { type: :integer, value: -5 }
+                             ])
 
     f.validate
     f.call
     assert f.errors?
   end
 
-  test "character substring with negative M is a parse error" do
+  test 'character substring with negative M is a parse error' do
     f = FunctionResolver.new('substring', [
-      {:type => :character, :value => 'ListPrice'},
-      {:type => :integer, :value => 1},
-      {:type => :integer, :value => -5}
-    ])
+                               { type: :character, value: 'ListPrice' },
+                               { type: :integer, value: 1 },
+                               { type: :integer, value: -5 }
+                             ])
 
     f.validate
     f.call
@@ -136,8 +138,8 @@ class FunctionResolverTest < Test::Unit::TestCase
 
   test 'trim with field' do
     f = FunctionResolver.new('trim', [
-      {:type => :field, :value => 'Name'}
-    ])
+                               { type: :field, value: 'Name' }
+                             ])
 
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
@@ -145,13 +147,13 @@ class FunctionResolverTest < Test::Unit::TestCase
 
     assert_equal :function, value[:type]
     assert_equal 'trim', value[:value]
-    assert_equal "Name", value[:args].first[:value]
+    assert_equal 'Name', value[:args].first[:value]
   end
 
   test 'trim with character' do
     f = FunctionResolver.new('trim', [
-      {:type => :character, :value => ' val '}
-    ])
+                               { type: :character, value: ' val ' }
+                             ])
 
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
@@ -162,7 +164,7 @@ class FunctionResolverTest < Test::Unit::TestCase
   end
 
   test "tolower('string')" do
-    f = FunctionResolver.new('tolower', [{:type => :character, :value => "STRING"}])
+    f = FunctionResolver.new('tolower', [{ type: :character, value: 'STRING' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -170,18 +172,18 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal "'string'", value[:value]
   end
 
-  test "toupper(SomeField)" do
-    f = FunctionResolver.new('toupper', [{:type => :field, :value => "City"}])
+  test 'toupper(SomeField)' do
+    f = FunctionResolver.new('toupper', [{ type: :field, value: 'City' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :function, value[:type]
     assert_equal 'toupper', value[:value]
-    assert_equal "City", value[:args].first[:value]
+    assert_equal 'City', value[:args].first[:value]
   end
 
   test "toupper('string')" do
-    f = FunctionResolver.new('toupper', [{:type => :character, :value => "string"}])
+    f = FunctionResolver.new('toupper', [{ type: :character, value: 'string' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -189,18 +191,18 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal "'STRING'", value[:value]
   end
 
-  test "length(SomeField)" do
-    f = FunctionResolver.new('length', [{:type => :field, :value => "City"}])
+  test 'length(SomeField)' do
+    f = FunctionResolver.new('length', [{ type: :field, value: 'City' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :function, value[:type]
     assert_equal 'length', value[:value]
-    assert_equal "City", value[:args].first[:value]
+    assert_equal 'City', value[:args].first[:value]
   end
 
   test "length('string')" do
-    f = FunctionResolver.new('length', [{:type => :character, :value => "string"}])
+    f = FunctionResolver.new('length', [{ type: :character, value: 'string' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -208,7 +210,7 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '6', value[:value]
   end
 
-  test "now()" do
+  test 'now()' do
     start = Time.now
     f = FunctionResolver.new('now', [])
     f.validate
@@ -216,10 +218,11 @@ class FunctionResolverTest < Test::Unit::TestCase
     value = f.call
     assert_equal :datetime, value[:type]
     test_time = Time.parse(value[:value])
-    assert (-5 < test_time - start && 5 > test_time - start), "Time range off by more than five seconds #{test_time - start} '#{test_time} - #{start}'"
+    assert (test_time - start > -5 && test_time - start < 5),
+           "Time range off by more than five seconds #{test_time - start} '#{test_time} - #{start}'"
   end
 
-  test "mindatetime()" do
+  test 'mindatetime()' do
     f = FunctionResolver.new('mindatetime', [])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
@@ -229,7 +232,7 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '1970-01-01T00:00:00+00:00', value[:value]
   end
 
-  test "maxdatetime()" do
+  test 'maxdatetime()' do
     f = FunctionResolver.new('maxdatetime', [])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
@@ -239,8 +242,8 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '9999-12-31T23:59:59+00:00', value[:value]
   end
 
-  test "floor(float)" do
-    f = FunctionResolver.new('floor', [{:type => :decimal, :value => 0.5}])
+  test 'floor(float)' do
+    f = FunctionResolver.new('floor', [{ type: :decimal, value: 0.5 }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -248,19 +251,19 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '0', value[:value]
   end
 
-  test "floor(Field)" do
-    f = FunctionResolver.new('floor', [{:type => :field, :value => 'ListPrice'}])
+  test 'floor(Field)' do
+    f = FunctionResolver.new('floor', [{ type: :field, value: 'ListPrice' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
 
     assert_equal :function, value[:type]
     assert_equal 'floor', value[:value]
-    assert_equal "ListPrice", value[:args].first[:value]
+    assert_equal 'ListPrice', value[:args].first[:value]
   end
 
-  test "ceiling(float)" do
-    f = FunctionResolver.new('ceiling', [{:type => :decimal, :value => 0.5}])
+  test 'ceiling(float)' do
+    f = FunctionResolver.new('ceiling', [{ type: :decimal, value: 0.5 }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -268,93 +271,344 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '1', value[:value]
   end
 
-  test "ceiling(Field)" do
-    f = FunctionResolver.new('ceiling', [{:type => :field, :value => 'ListPrice'}])
+  test 'ceiling(Field)' do
+    f = FunctionResolver.new('ceiling', [{ type: :field, value: 'ListPrice' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
 
     assert_equal :function, value[:type]
     assert_equal 'ceiling', value[:value]
-    assert_equal "ListPrice", value[:args].first[:value]
+    assert_equal 'ListPrice', value[:args].first[:value]
+  end
+
+  test 'seconds()' do
+    test_time = Time.new(2019, 4, 1, 8, 30, 20, 0)
+
+    f = FunctionResolver.new('seconds', [{ type: :integer, value: 7 }])
+    f.expects(:current_time).returns(test_time)
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :datetime, value[:type]
+    d = DateTime.parse(value[:value])
+    assert_equal test_time.year, d.year
+    assert_equal test_time.month, d.month
+    assert_equal test_time.mday, d.mday
+    assert_equal test_time.hour, d.hour
+    assert_equal test_time.min, d.min
+    assert_equal test_time.sec + 7, d.sec
+
+    f = FunctionResolver.new('seconds', [{ type: :integer, value: -21 }])
+    f.expects(:current_time).returns(test_time)
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :datetime, value[:type]
+    d = DateTime.parse(value[:value])
+    assert_equal test_time.year, d.year
+    assert_equal test_time.month, d.month
+    assert_equal test_time.mday, d.mday
+    assert_equal test_time.hour, d.hour
+    assert_equal test_time.min - 1, d.min
+    assert_equal 29, d.min
+    assert_equal 59, d.sec
+
+    f = FunctionResolver.new('seconds', [{ type: :integer,
+                                           value: -Sparkql::FunctionResolver::SECONDS_IN_DAY }])
+    f.expects(:current_time).returns(test_time)
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :datetime, value[:type]
+    d = DateTime.parse(value[:value])
+    assert_equal test_time.year, d.year
+    assert_equal test_time.month - 1, d.month
+    assert_equal 31, d.mday
+    assert_equal test_time.hour, d.hour
+    assert_equal test_time.min, d.min
+    assert_equal test_time.min, d.min
+    assert_equal test_time.sec, d.sec
   end
 
-  test "days()" do
-    d = Date.new(2012,10,20)
-    Date.expects(:today).returns(d)
-    dt = DateTime.new(d.year, d.month,d.day, 0,0,0, DateTime.now.offset)
-    start = Time.parse(dt.to_s)
-    f = FunctionResolver.new('days', [{:type=>:integer, :value =>7}])
+  test 'minutes()' do
+    test_time = Time.new(2019, 4, 1, 8, 30, 20, 0)
+
+    f = FunctionResolver.new('minutes', [{ type: :integer, value: 7 }])
+    f.expects(:current_time).returns(test_time)
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :datetime, value[:type]
+    d = DateTime.parse(value[:value])
+    assert_equal test_time.year, d.year
+    assert_equal test_time.month, d.month
+    assert_equal test_time.mday, d.mday
+    assert_equal test_time.hour, d.hour
+    assert_equal test_time.min + 7, d.min
+    assert_equal test_time.sec, d.sec
+
+    f = FunctionResolver.new('minutes', [{ type: :integer, value: -37 }])
+    f.expects(:current_time).returns(test_time)
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :datetime, value[:type]
+    d = DateTime.parse(value[:value])
+    assert_equal test_time.year, d.year
+    assert_equal test_time.month, d.month
+    assert_equal test_time.mday, d.mday
+    assert_equal test_time.hour - 1, d.hour
+    assert_equal 53, d.min
+
+    f = FunctionResolver.new('minutes', [{ type: :integer,
+                                           value: -1440 }])
+    f.expects(:current_time).returns(test_time)
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :datetime, value[:type]
+    d = DateTime.parse(value[:value])
+    assert_equal test_time.year, d.year
+    assert_equal test_time.month - 1, d.month
+    assert_equal 31, d.mday
+    assert_equal test_time.hour, d.hour
+    assert_equal test_time.min, d.min
+  end
+
+  test 'hours(), same day' do
+    test_time = Time.new(2019, 4, 1, 8, 30, 20, 0)
+    tests = [1, -1, 5, -5, 12]
+
+    tests.each do |offset|
+      f = FunctionResolver.new('hours', [{ type: :integer,
+                                           value: offset }])
+      f.expects(:current_time).returns(test_time)
+      f.validate
+      assert !f.errors?, "Errors #{f.errors.inspect}"
+      value = f.call
+
+      assert_equal :datetime, value[:type]
+      d = DateTime.parse(value[:value])
+      assert_equal test_time.year, d.year
+      assert_equal test_time.month, d.month
+      assert_equal test_time.mday, d.mday
+      assert_equal test_time.hour + offset, d.hour
+      assert_equal test_time.min, d.min
+      assert_equal test_time.sec, d.sec
+    end
+  end
+
+  test 'hours(), wrap day' do
+    test_time = Time.new(2019, 4, 1, 8, 30, 20, 0)
+
+    # Jump forward a few days, and a few hours.
+    f = FunctionResolver.new('hours', [{ type: :integer, value: 52 }])
+    f.expects(:current_time).returns(test_time)
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :datetime, value[:type]
+    d = DateTime.parse(value[:value])
+    assert_equal test_time.year, d.year
+    assert_equal test_time.month, d.month
+    assert_equal test_time.mday + 2, d.mday
+    assert_equal test_time.hour + 4, d.hour
+    assert_equal test_time.min, d.min
+
+    # Drop back to the previous day, which'll also hit the previous month
+    f = FunctionResolver.new('hours', [{ type: :integer, value: -24 }])
+    f.expects(:current_time).returns(test_time)
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :datetime, value[:type]
+    d = DateTime.parse(value[:value])
+    assert_equal test_time.year, d.year
+    assert_equal test_time.month - 1, d.month
+    assert_equal 31, d.mday
+    assert_equal test_time.hour, d.hour
+    assert_equal test_time.min, d.min
+
+    # Drop back one full year's worth of hours.
+    f = FunctionResolver.new('hours', [{ type: :integer, value: -8760 }])
+    f.expects(:current_time).returns(test_time)
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :datetime, value[:type]
+    d = DateTime.parse(value[:value])
+    assert_equal test_time.year - 1, d.year
+    assert_equal test_time.month, d.month
+    assert_equal test_time.mday, d.mday
+    assert_equal test_time.hour, d.hour
+    assert_equal test_time.min, d.min
+  end
+
+  test 'days()' do
+    test_date = Date.new(2012, 10, 20) # Sat, 20 Oct 2012 00:00:00 GMT
+    f = FunctionResolver.new('days', [{ type: :integer, value: 7 }])
+    f.expects(:current_date).returns(test_date)
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :date, value[:type]
-    test_time = Time.parse(value[:value])
-    assert (615000 > test_time - start && 600000 < test_time - start), "Time range off by more than five seconds #{test_time - start} '#{test_time} - #{start}'"
+    assert_equal '2012-10-27', value[:value]
+  end
+
+  test 'weekdays()' do
+    friday = Date.new(2012, 10, 19)
+    saturday = Date.new(2012, 10, 20)
+    sunday = Date.new(2012, 10, 21)
+    monday = Date.new(2012, 10, 22)
+    {
+      friday => [
+        [-5, '2012-10-12'],
+        [-4, '2012-10-15'],
+        [-1, '2012-10-18'],
+        [0, '2012-10-19'],
+        [1, '2012-10-22'],
+        [2, '2012-10-23'],
+        [5, '2012-10-26'],
+        [6, '2012-10-29'],
+        [7, '2012-10-30'],
+        [31, '2012-12-03']
+      ],
+      saturday => [
+        [-6, '2012-10-12'],
+        [-5, '2012-10-15'],
+        [-1, '2012-10-19'],
+        [0, '2012-10-22'],
+        [1, '2012-10-22'],
+        [2, '2012-10-23'],
+        [3, '2012-10-24'],
+        [4, '2012-10-25'],
+        [5, '2012-10-26'],
+        [6, '2012-10-29'],
+        [7, '2012-10-30'],
+        [31, '2012-12-03']
+      ],
+      sunday => [
+        [-6, '2012-10-12'],
+        [-5, '2012-10-15'],
+        [-1, '2012-10-19'],
+        [0, '2012-10-22'],
+        [1, '2012-10-22'],
+        [2, '2012-10-23'],
+        [5, '2012-10-26'],
+        [6, '2012-10-29'],
+        [7, '2012-10-30'],
+        [31, '2012-12-03']
+      ],
+      monday => [
+        [-6, '2012-10-12'],
+        [-5, '2012-10-15'],
+        [-1, '2012-10-19'],
+        [0, '2012-10-22'],
+        [1, '2012-10-23'],
+        [2, '2012-10-24'],
+        [5, '2012-10-29'],
+        [6, '2012-10-30'],
+        [7, '2012-10-31'],
+        [31, '2012-12-04']
+      ]
+    }.each do |test_date, weekday_tests|
+      weekday_tests.each do |days, expected_value|
+        f = FunctionResolver.new('weekdays', [{ type: :integer, value: days }])
+        f.expects(:current_date).returns(test_date)
+        f.validate
+        assert !f.errors?, "#{test_date}: #{days} = #{expected_value}"
+        value = f.call
+        assert_equal :date, value[:type]
+        assert_equal expected_value, value[:value], "#{test_date}: #{days} = #{expected_value}"
+      end
+    end
   end
 
-  test "months()" do
+  test 'months()' do
     dt = DateTime.new(2014, 1, 6, 0, 0, 0, 0)
     DateTime.expects(:now).once.returns(dt)
 
-    f = FunctionResolver.new('months', [{:type=>:integer, :value =>3}])
+    f = FunctionResolver.new('months', [{ type: :integer, value: 3 }])
     f.validate
     assert !f.errors?, "Errors resolving months(): #{f.errors.inspect}"
     value = f.call
     assert_equal :date, value[:type]
 
-    assert_equal "2014-04-06", value[:value]
+    assert_equal '2014-04-06', value[:value]
   end
-  
-  test "years()" do
+
+  test 'years()' do
     dt = DateTime.new(2014, 1, 6, 0, 0, 0, 0)
     DateTime.expects(:now).once.returns(dt)
-    f = FunctionResolver.new('years', [{:type=>:integer, :value =>-4}])
+    f = FunctionResolver.new('years', [{ type: :integer, value: -4 }])
     f.validate
     assert !f.errors?, "Errors resolving years(): #{f.errors.inspect}"
     value = f.call
     assert_equal :date, value[:type]
-    assert_equal '2010-01-06', value[:value], "negative values should go back in time"
+    assert_equal '2010-01-06', value[:value], 'negative values should go back in time'
   end
 
-  test "year(), month(), and day()" do
-    ['year', 'month', 'day'].each do |function|
-      f = FunctionResolver.new(function, [{:type => :field, :value => "OriginalEntryTimestamp"}])
+  test 'year(), month(), and day()' do
+    %w[year month day].each do |function|
+      f = FunctionResolver.new(function, [{ type: :field, value: 'OriginalEntryTimestamp' }])
       f.validate
       assert !f.errors?, "Errors #{f.errors.inspect}"
       value = f.call
       assert_equal :function, value[:type]
       assert_equal function, value[:value]
-      assert_equal "OriginalEntryTimestamp", value[:args].first[:value]
+      assert_equal 'OriginalEntryTimestamp', value[:args].first[:value]
     end
   end
 
-  test "hour(), minute(), and second()" do
-    ['year', 'month', 'day'].each do |function|
-      f = FunctionResolver.new(function, [{:type => :field, :value => "OriginalEntryTimestamp"}])
+  test 'hour(), minute(), and second()' do
+    %w[year month day].each do |function|
+      f = FunctionResolver.new(function, [{ type: :field, value: 'OriginalEntryTimestamp' }])
       f.validate
       assert !f.errors?, "Errors #{f.errors.inspect}"
       value = f.call
       assert_equal :function, value[:type]
       assert_equal function, value[:value]
-      assert_equal "OriginalEntryTimestamp", value[:args].first[:value]
+      assert_equal 'OriginalEntryTimestamp', value[:args].first[:value]
     end
   end
 
-  test "fractionalseconds()" do
-    f = FunctionResolver.new('fractionalseconds', [{:type => :field, :value => "OriginalEntryTimestamp"}])
+  test 'day of week and day of year parse' do
+    %w[dayofyear dayofweek].each do |function|
+      f = FunctionResolver.new(function, [{ type: :field, value: 'OriginalEntryTimestamp' }])
+      f.validate
+      assert !f.errors?, "Errors #{f.errors.inspect}"
+      value = f.call
+      assert_equal :function, value[:type]
+      assert_equal function, value[:value]
+      assert_equal 'OriginalEntryTimestamp', value[:args].first[:value]
+    end
+  end
+
+  test 'fractionalseconds()' do
+    f = FunctionResolver.new('fractionalseconds', [{ type: :field, value: 'OriginalEntryTimestamp' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :function, value[:type]
     assert_equal 'fractionalseconds', value[:value]
-    assert_equal "OriginalEntryTimestamp", value[:args].first[:value]
+    assert_equal 'OriginalEntryTimestamp', value[:args].first[:value]
   end
 
   # Polygon searches
-  
-  test "radius()" do
-    f = FunctionResolver.new('radius', [{:type => :character, :value => "35.12 -68.33"},{:type => :decimal, :value => 1.0}])
+
+  test 'radius()' do
+    f = FunctionResolver.new('radius',
+                             [{ type: :character, value: '35.12 -68.33' }, { type: :decimal, value: 1.0 }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -364,38 +618,41 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal 1.0, value[:value].radius, "#{value[:value].inspect} "
   end
 
-  test "radius() can be overloaded with a ListingKey" do
-    f = FunctionResolver.new('radius', [{:type => :character, :value => "20100000000000000000000000"},
-                {:type => :decimal, :value => 1.0}])
+  test 'radius() can be overloaded with a ListingKey' do
+    f = FunctionResolver.new('radius', [{ type: :character, value: '20100000000000000000000000' },
+                                        { type: :decimal, value: 1.0 }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :shape, value[:type]
     assert_equal Sparkql::Geo::RecordRadius, value[:value].class
-    assert_equal "20100000000000000000000000", value[:value].record_id, "#{value[:value].inspect} "
+    assert_equal '20100000000000000000000000', value[:value].record_id, "#{value[:value].inspect} "
     assert_equal 1.0, value[:value].radius, "#{value[:value].inspect} "
   end
 
-  test "radius() fails if not given coords or a flex ID" do
-    f = FunctionResolver.new('radius', [{:type => :character, :value => "35.12,-68.33"},
-                {:type => :decimal, :value => 1.0}])
+  test 'radius() fails if not given coords or a flex ID' do
+    f = FunctionResolver.new('radius', [{ type: :character, value: '35.12,-68.33' },
+                                        { type: :decimal, value: 1.0 }])
     f.validate
     f.call
     assert f.errors?
   end
 
-  test "polygon()" do
-    f = FunctionResolver.new('polygon', [{:type => :character, :value => "35.12 -68.33,35.12 -68.32, 35.13 -68.32,35.13 -68.33"}])
+  test 'polygon()' do
+    f = FunctionResolver.new('polygon',
+                             [{ type: :character,
+                                value: '35.12 -68.33,35.12 -68.32, 35.13 -68.32,35.13 -68.33' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :shape, value[:type]
     assert_equal GeoRuby::SimpleFeatures::Polygon, value[:value].class
-    assert_equal [[-68.33, 35.12], [-68.32, 35.12], [-68.32, 35.13], [-68.33, 35.13], [-68.33, 35.12]], value[:value].to_coordinates.first, "#{value[:value].inspect} "
+    assert_equal [[-68.33, 35.12], [-68.32, 35.12], [-68.32, 35.13], [-68.33, 35.13], [-68.33, 35.12]],
+                 value[:value].to_coordinates.first, "#{value[:value].inspect} "
   end
- 
-  test "linestring()" do
-    f = FunctionResolver.new('linestring', [{:type => :character, :value => "35.12 -68.33,35.12 -68.32"}])
+
+  test 'linestring()' do
+    f = FunctionResolver.new('linestring', [{ type: :character, value: '35.12 -68.33,35.12 -68.32' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -404,70 +661,72 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal [[-68.33, 35.12], [-68.32, 35.12]], value[:value].to_coordinates, "#{value[:value].inspect} "
   end
 
-  test "rectangle()" do
-    f = FunctionResolver.new('rectangle', [{:type => :character, :value => "35.12 -68.33, 35.13 -68.32"}])
+  test 'rectangle()' do
+    f = FunctionResolver.new('rectangle', [{ type: :character, value: '35.12 -68.33, 35.13 -68.32' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :shape, value[:type]
     assert_equal GeoRuby::SimpleFeatures::Polygon, value[:value].class
-    assert_equal [[-68.33,35.12], [-68.32,35.12], [-68.32,35.13], [-68.33,35.13], [-68.33,35.12]], value[:value].to_coordinates.first, "#{value[:value].inspect} "
+    assert_equal [[-68.33, 35.12], [-68.32, 35.12], [-68.32, 35.13], [-68.33, 35.13], [-68.33, 35.12]],
+                 value[:value].to_coordinates.first, "#{value[:value].inspect} "
   end
 
-  test "range()" do
-    f = FunctionResolver.new('range', [{:type => :character, :value => "M01"},
-                                              {:type => :character, :value => "M05"}])
+  test 'range()' do
+    f = FunctionResolver.new('range', [{ type: :character, value: 'M01' },
+                                       { type: :character, value: 'M05' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :character, value[:type]
-    assert_equal ["M01", "M05"], value[:value]
+    assert_equal %w[M01 M05], value[:value]
   end
-  
-  test "invalid params" do
-    f = FunctionResolver.new('now', [{:type => :character, :value=>'bad value'}])
+
+  test 'invalid params' do
+    f = FunctionResolver.new('now', [{ type: :character, value: 'bad value' }])
     f.validate
     assert f.errors?, "'now' function does not support parameters"
-    
+
     f = FunctionResolver.new('days', [])
     f.validate
     assert f.errors?, "'days' function requires one parameter"
-      
-    f = FunctionResolver.new('days', [{:type => :character, :value=>'bad value'}])
+
+    f = FunctionResolver.new('days', [{ type: :character, value: 'bad value' }])
     f.validate
     assert f.errors?, "'days' function needs integer parameter"
   end
 
-  test "assert nil returned when function called with errors" do
-    f = FunctionResolver.new('radius', [{:type => :character, 
-        :value => "35.12 -68.33, 35.13 -68.34"},{:type => :decimal, 
-        :value => 1.0}])
+  test 'assert nil returned when function called with errors' do
+    f = FunctionResolver.new('radius', [{ type: :character,
+                                          value: '35.12 -68.33, 35.13 -68.34' }, { type: :decimal,
+                                                                                   value: 1.0 }])
     assert_nil f.call
   end
-  
-  test "return_type" do 
-    f = FunctionResolver.new('radius', [{:type => :character, 
-        :value => "35.12 -68.33, 35.13 -68.34"},{:type => :decimal, 
-        :value => 1.0}])
+
+  test 'return_type' do
+    f = FunctionResolver.new('radius', [{ type: :character,
+                                          value: '35.12 -68.33, 35.13 -68.34' }, { type: :decimal,
+                                                                                   value: 1.0 }])
     assert_equal :shape, f.return_type
   end
 
   test 'return_type for cast()' do
-    f = FunctionResolver.new('cast', [{:type => :character, 
-        :value => "1"},{:type => :character, 
-        :value => 'decimal'}])
+    f = FunctionResolver.new('cast', [{ type: :character,
+                                        value: '1' }, { type: :character,
+                                                        value: 'decimal' }])
 
     assert_equal :decimal, f.return_type
 
-    f = FunctionResolver.new('cast', [{:type => :character, 
-        :value => "1"},{:type => :character, 
-        :value => 'integer'}])
+    f = FunctionResolver.new('cast', [{ type: :character,
+                                        value: '1' }, { type: :character,
+                                                        value: 'integer' }])
 
     assert_equal :integer, f.return_type
   end
 
-  test "cast() decimal to integer" do
-    f = FunctionResolver.new('cast', [{:type => :decimal, :value => '1.2'}, {type: :character, :value => 'integer'}])
+  test 'cast() decimal to integer' do
+    f = FunctionResolver.new('cast',
+                             [{ type: :decimal, value: '1.2' }, { type: :character, value: 'integer' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -476,8 +735,8 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '1', value[:value]
   end
 
-  test "cast() integer to decimal" do
-    f = FunctionResolver.new('cast', [{:type => :decimal, :value => '1'}, {type: :character, :value => 'decimal'}])
+  test 'cast() integer to decimal' do
+    f = FunctionResolver.new('cast', [{ type: :decimal, value: '1' }, { type: :character, value: 'decimal' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -486,8 +745,8 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '1.0', value[:value]
   end
 
-  test "cast() nil to integer" do
-    f = FunctionResolver.new('cast', [{:type => :null, :value => 'NULL'}, {type: :character, :value => 'integer'}])
+  test 'cast() nil to integer' do
+    f = FunctionResolver.new('cast', [{ type: :null, value: 'NULL' }, { type: :character, value: 'integer' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -496,8 +755,8 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '0', value[:value]
   end
 
-  test "cast() nil to decimal" do
-    f = FunctionResolver.new('cast', [{:type => :null, :value => 'NULL'}, {type: :character, :value => 'decimal'}])
+  test 'cast() nil to decimal' do
+    f = FunctionResolver.new('cast', [{ type: :null, value: 'NULL' }, { type: :character, value: 'decimal' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -506,8 +765,9 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '0.0', value[:value]
   end
 
-  test "cast() nil to character" do
-    f = FunctionResolver.new('cast', [{:type => :null, :value => 'NULL'}, {type: :character, :value => 'character'}])
+  test 'cast() nil to character' do
+    f = FunctionResolver.new('cast',
+                             [{ type: :null, value: 'NULL' }, { type: :character, value: 'character' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -516,39 +776,43 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal "''", value[:value]
   end
 
-  test "cast() character to decimal" do
-    f = FunctionResolver.new('cast', [{:type => :character, :value => "1.1"}, {type: :character, :value => 'decimal'}])
+  test 'cast() character to decimal' do
+    f = FunctionResolver.new('cast',
+                             [{ type: :character, value: '1.1' }, { type: :character, value: 'decimal' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
 
     assert_equal :decimal, value[:type]
-    assert_equal "1.1", value[:value]
+    assert_equal '1.1', value[:value]
   end
 
-  test "cast() character to integer" do
-    f = FunctionResolver.new('cast', [{:type => :character, :value => "1"}, {type: :character, :value => 'integer'}])
+  test 'cast() character to integer' do
+    f = FunctionResolver.new('cast',
+                             [{ type: :character, value: '1' }, { type: :character, value: 'integer' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
 
     assert_equal :integer, value[:type]
-    assert_equal "1", value[:value]
+    assert_equal '1', value[:value]
   end
 
-  test "cast() Field" do
-    f = FunctionResolver.new('cast', [{:type => :field, :value => 'Bedrooms'}, {type: :character, :value => 'character'}])
+  test 'cast() Field' do
+    f = FunctionResolver.new('cast',
+                             [{ type: :field, value: 'Bedrooms' }, { type: :character, value: 'character' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
 
     assert_equal :function, value[:type]
     assert_equal 'cast', value[:value]
-    assert_equal ['Bedrooms', 'character'], value[:args].map { |v| v[:value]}
+    assert_equal(%w[Bedrooms character], value[:args].map{ |v| v[:value] })
   end
 
-  test "invalid cast returns null" do
-    f = FunctionResolver.new('cast', [{:type => :character, :value => '1.1.1'}, {type: :character, :value => 'integer'}])
+  test 'invalid cast returns null' do
+    f = FunctionResolver.new('cast',
+                             [{ type: :character, value: '1.1.1' }, { type: :character, value: 'integer' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -557,14 +821,14 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal 'NULL', value[:value]
   end
 
-  test "invalid function" do
+  test 'invalid function' do
     f = FunctionResolver.new('then', [])
     f.validate
     assert f.errors?, "'then' is not a function"
   end
 
-  test "time(datetime)" do
-    f = FunctionResolver.new('time', [{:type => :datetime, :value => EXAMPLE_DATE}])
+  test 'time(datetime)' do
+    f = FunctionResolver.new('time', [{ type: :datetime, value: EXAMPLE_DATE }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -572,8 +836,8 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '10:22:15.422804000', value[:value]
   end
 
-  test "date(datetime)" do
-    f = FunctionResolver.new('date', [{:type => :datetime, :value => EXAMPLE_DATE}])
+  test 'date(datetime)' do
+    f = FunctionResolver.new('date', [{ type: :datetime, value: EXAMPLE_DATE }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -581,39 +845,39 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert_equal '2013-07-26', value[:value]
   end
 
-###
-# Delayed functions. These functions don't get run immediately and require
-#  resolution by the backing system
-###
-  
-  test "time(field)" do
-    f = FunctionResolver.new('time', [{:type => :field, :value => "OriginalEntryTimestamp"}])
+  ###
+  # Delayed functions. These functions don't get run immediately and require
+  #  resolution by the backing system
+  ###
+
+  test 'time(field)' do
+    f = FunctionResolver.new('time', [{ type: :field, value: 'OriginalEntryTimestamp' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :function, value[:type]
     assert_equal 'time', value[:value]
-    assert_equal "OriginalEntryTimestamp", value[:args].first[:value]
+    assert_equal 'OriginalEntryTimestamp', value[:args].first[:value]
   end
-  
-  test "date(field)" do
-    f = FunctionResolver.new('date', [{:type => :field, :value => "OriginalEntryTimestamp"}])
+
+  test 'date(field)' do
+    f = FunctionResolver.new('date', [{ type: :field, value: 'OriginalEntryTimestamp' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :function, value[:type]
     assert_equal 'date', value[:value]
-    assert_equal "OriginalEntryTimestamp", value[:args].first[:value]
+    assert_equal 'OriginalEntryTimestamp', value[:args].first[:value]
   end
 
-  test "startswith(), endswith() and contains()" do
-    [{'startswith' => "^far"},
-     {'endswith' => "far$"},
-     {'contains' => "far"}].each do |test_case|
+  test 'startswith(), endswith() and contains()' do
+    [{ 'startswith' => '^far' },
+     { 'endswith' => 'far$' },
+     { 'contains' => 'far' }].each do |test_case|
       function = test_case.keys.first
       expected_value = test_case[function]
 
-      f = FunctionResolver.new(function, [{:type => :character, :value => "far"}])
+      f = FunctionResolver.new(function, [{ type: :character, value: 'far' }])
       f.validate
       assert !f.errors?, "Errors #{f.errors.inspect}"
       value = f.call
@@ -626,8 +890,8 @@ class FunctionResolverTest < Test::Unit::TestCase
 
   test 'wkt()' do
     f = FunctionResolver.new('wkt',
-                             [{:type => :character,
-                               :value => "SRID=12345;POLYGON((-127.89734578345 45.234534534,-127.89734578345 45.234534534,-127.89734578345 45.234534534,-127.89734578345 45.234534534))"}])
+                             [{ type: :character,
+                                value: 'SRID=12345;POLYGON((-127.89734578345 45.234534534,-127.89734578345 45.234534534,-127.89734578345 45.234534534,-127.89734578345 45.234534534))' }])
     f.validate
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
@@ -636,8 +900,8 @@ class FunctionResolverTest < Test::Unit::TestCase
 
   test 'wkt() invalid params' do
     f = FunctionResolver.new('wkt',
-                             [{:type => :character,
-                               :value => "POLYGON((45.234534534))"}])
+                             [{ type: :character,
+                                value: 'POLYGON((45.234534534))' }])
     f.validate
     f.call
     assert f.errors?