sparkql 1.2.4 → 1.2.8

data/lib/sparkql/parser.rb

@@ -1,6 +1,6 @@
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.4.14
+# This file is automatically generated by Racc 1.4.15
 # from Racc grammer file "".
 #
 

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

data/lib/sparkql/parser_tools.rb

@@ -126,6 +126,8 @@ module Sparkql::ParserTools
   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,
@@ -260,6 +262,8 @@ module Sparkql::ParserTools
   end
 
   def group_fold(exp)
+    @lexer.leveldown
+    @lexer.block_group_identifier -= 1
     exp
   end
 

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,37 @@
+# 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 'all with field' do
+    f = FunctionResolver.new('all', [
+                               { type: :field, value: 'Name' }
+                             ])
+
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :function, value[:type]
+    assert_equal 'all', value[:value]
+    assert_equal 'Name', value[:args].first[:value]
+  end
+
+  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 +39,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 +64,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 +93,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 +105,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 +122,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 +152,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 +161,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 +178,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 +186,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 +205,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 +224,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 +232,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 +246,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 +256,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 +265,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 +285,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 +632,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 +675,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 +749,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 +759,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 +769,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 +779,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 +790,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 +835,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 +850,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 +859,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 +904,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 +914,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?