sparkql 1.2.8 → 1.3.0

data/test/unit/evaluator_test.rb

@@ -46,7 +46,7 @@ class EvaluatorTest < Test::Unit::TestCase
       assert !sample(filter), "Filter: #{filter}"
     end
   end
-  
+
   # One failing Not expression in a set should always fail. Here we ensure every
   # permutation of one failing
   def test_nots_stay_bad
@@ -56,7 +56,7 @@ class EvaluatorTest < Test::Unit::TestCase
         expressions << "Test Eq #{i == j}"
       end
       # Add the unary not to the front!
-      filter = "Not " + expressions.join(" Not ")
+      filter = "Not #{expressions.join(' Not ')}"
       assert !sample(filter), "Filter: #{filter}"
     end
   end
@@ -97,24 +97,23 @@ class EvaluatorTest < Test::Unit::TestCase
     assert !sample("Test Eq true Not (Not Test Eq false)")
     assert sample("Not (Not Test Eq true)")
     assert sample("Not (Not(Not Test Eq true))")
-    assert !sample("Test Eq false And Test Eq true Not Test Eq false") 
+    assert !sample("Test Eq false And Test Eq true Not Test Eq false")
   end
-  
+
   def test_examples
     # This one is based on a real life example that had problems.
     #
-    # CurrentPrice Bt 130000.00,180000.00 And PropertySubType Eq 'Single Family Residence' And 
-    # SchoolDistrict Eq 'Byron Center','Grandville','Jenison' And MlsStatus Eq 'Active' And 
-    # BathsTotal Bt 1.50,9999.00 And BedsTotal Bt 3,99 And PropertyType Eq 'A' 
-    # Not "Garage"."Garage2" Eq 'No' And "Pool"."OutdoorAbove" Eq true 
+    # CurrentPrice Bt 130000.00,180000.00 And PropertySubType Eq 'Single Family Residence' And
+    # SchoolDistrict Eq 'Byron Center','Grandville','Jenison' And MlsStatus Eq 'Active' And
+    # BathsTotal Bt 1.50,9999.00 And BedsTotal Bt 3,99 And PropertyType Eq 'A'
+    # Not "Garage"."Garage2" Eq 'No' And "Pool"."OutdoorAbove" Eq true
     # And "Pool"."OutdoorInground" Eq true Not "Substructure"."Michigan Basement" Eq true
 
-    assert !sample("Test Eq false And Test Eq true And " + 
-      "Test Eq false And Test Eq true And " + 
-      "Test Eq true And Test Eq true And Test Eq true " + 
-      "Not Test Eq false And Test Eq false " + 
-      "And Test Eq false Not Test Eq false"
-    )
+    assert !sample("Test Eq false And Test Eq true And " \
+      "Test Eq false And Test Eq true And " \
+      "Test Eq true And Test Eq true And Test Eq true " \
+      "Not Test Eq false And Test Eq false " \
+      "And Test Eq false Not Test Eq false")
   end
 
   def test_optimizations
@@ -133,10 +132,10 @@ class EvaluatorTest < Test::Unit::TestCase
     assert !sample("MlsStatus Eq false And PropertyType Eq true And (City Eq true Or City Eq false)")
   end
 
-  def sample filter
+  def sample(filter)
     @parser = Parser.new
     @expressions = @parser.parse(filter)
-    @evaluator = Evaluator.new(BooleanOrBustExpressionResolver.new())
+    @evaluator = Evaluator.new(BooleanOrBustExpressionResolver.new)
     @evaluator.evaluate(@expressions)
   end
 end

data/test/unit/expression_state_test.rb

@@ -7,17 +7,17 @@ class ExpressionStateTest < Test::Unit::TestCase
     @subject = ExpressionState.new
     @parser = Parser.new
   end
-  
+
   def test_needs_join
     filter = '"General Property Description"."Taxes" Lt 500.0'
     process(filter)
     assert @subject.needs_join?
   end
-  
+
   def test_or
     filter = '"General Property Description"."Taxes" Lt 500.0 Or "General Property Description"."Taxes" Gt 400.0'
     process(filter)
-    assert !@subject.needs_join?, "#{@subject.inspect} Expressions:#{ @expressions.inspect}"
+    assert !@subject.needs_join?, "#{@subject.inspect} Expressions:#{@expressions.inspect}"
   end
 
   def test_not
@@ -33,31 +33,31 @@ class ExpressionStateTest < Test::Unit::TestCase
   end
 
   def test_and_or
-    filter = '"General Property Description"."Taxes" Lt 500.0 And "General Property Description"."Taxes2" ' + 
-      'Eq 1.0 Or "General Property Description"."Taxes" Gt 400.0'
+    filter = '"General Property Description"."Taxes" Lt 500.0 And "General Property Description"."Taxes2" ' \
+             'Eq 1.0 Or "General Property Description"."Taxes" Gt 400.0'
     process(filter)
     assert !@subject.needs_join?
   end
 
   def test_or_and
-    filter = '"General Property Description"."Taxes" Lt 500.0 Or "General Property Description"."Taxes" ' +
-      'Gt 400.0 And "General Property Description"."Taxes2" Eq 1.0'
+    filter = '"General Property Description"."Taxes" Lt 500.0 Or "General Property Description"."Taxes" ' \
+             'Gt 400.0 And "General Property Description"."Taxes2" Eq 1.0'
     process(filter)
     assert @subject.needs_join?
   end
-  
+
   def test_or_with_standard_field
     filter = 'Test Eq 0.0 Or "General Property Description"."Taxes" Lt 500.0'
     process(filter)
     assert @subject.needs_join?
   end
-  
+
   # Nesting
   def test_nested_or
     parse '"General Property Description"."Taxes" Lt 5.0 Or ("General Property Description"."Taxes" Gt 4.0)'
     @expressions.each do |ex|
       @subject.push(ex)
-      assert @subject.needs_join?, "#{@subject.inspect} Expression:#{ ex.inspect}"
+      assert @subject.needs_join?, "#{@subject.inspect} Expression:#{ex.inspect}"
     end
   end
 
@@ -70,20 +70,20 @@ class ExpressionStateTest < Test::Unit::TestCase
     @subject.push(@expressions[2])
     assert !@subject.needs_join?
   end
-  
+
   # Nesting
   def test_nested_and
     parse '"Tax"."Taxes" Lt 5.0 Or ("Tax"."Taxes" Gt 4.0 And "Tax"."Taxes" Gt 2.0)'
     @expressions.each do |ex|
       @subject.push(ex)
-      assert @subject.needs_join?, "#{@subject.inspect} Expression:#{ ex.inspect}"
+      assert @subject.needs_join?, "#{@subject.inspect} Expression:#{ex.inspect}"
     end
   end
-  
+
   def parse(filter)
     @expressions = @parser.parse(filter)
   end
-  
+
   def process(filter)
     @expressions = @parser.parse(filter)
     @expressions.each do |ex|
@@ -91,5 +91,4 @@ class ExpressionStateTest < Test::Unit::TestCase
     end
     @expressions
   end
-    
 end

data/test/unit/function_resolver_test.rb

@@ -6,7 +6,40 @@ require 'sparkql/geo'
 class FunctionResolverTest < Test::Unit::TestCase
   include Sparkql
 
-  EXAMPLE_DATE = DateTime.parse('2013-07-26T10:22:15.422804')
+  YEAR = 2021
+  MONTH = 12
+  DAY = 31
+  HOURS = 0
+  MINUTES = 1
+  SECONDS = 2
+  MILLI = 123_456
+  SECONDSF = 2.123456
+
+  EXAMPLE_DATE = Time.new(YEAR, MONTH, DAY, HOURS, MINUTES, SECONDSF)
+  TIME_TESTS = {
+    year: YEAR,
+    month: MONTH,
+    mday: DAY,
+    hour: HOURS,
+    min: MINUTES,
+    sec: SECONDS
+  }.freeze
+
+  def assert_times(call_value, expected_call_type = :datetime, overrides = {})
+    assert_equal call_value[:type], expected_call_type
+    test_time = Time.parse(call_value[:value])
+    tests = TIME_TESTS.merge(overrides)
+    tests.each do |key, value|
+      assert_equal value, test_time.send(key), "#{key}: #{test_time}"
+    end
+  end
+
+  test '#lookup' do
+    good = FunctionResolver.lookup('all')
+    bad = FunctionResolver.lookup('not_function')
+    assert !good.nil?
+    assert_nil bad
+  end
 
   test 'all with field' do
     f = FunctionResolver.new('all', [
@@ -297,186 +330,119 @@ class FunctionResolverTest < Test::Unit::TestCase
   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 = FunctionResolver.new('seconds',
+                             [{ type: :integer, value: 7 }],
+                             current_timestamp: EXAMPLE_DATE)
     f.validate
-    assert !f.errors?, "Errors #{f.errors.inspect}"
-    value = f.call
+    assert !f.errors?
+    assert_times f.call, :datetime, sec: SECONDS + 7
 
-    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 = FunctionResolver.new('seconds',
+                             [{ type: :integer, value: -3 }],
+                             current_timestamp: EXAMPLE_DATE)
     f.validate
-    assert !f.errors?, "Errors #{f.errors.inspect}"
-    value = f.call
+    assert !f.errors?
+    assert_times f.call, :datetime, sec: 59, min: MINUTES - 1
 
-    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 = FunctionResolver.new('seconds',
+                             [{ type: :integer, value: Sparkql::FunctionResolver::SECONDS_IN_DAY }],
+                             current_timestamp: EXAMPLE_DATE)
     f.validate
-    assert !f.errors?, "Errors #{f.errors.inspect}"
-    value = f.call
+    assert !f.errors?
 
-    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
+    assert_times f.call, :datetime, year: 2022, mday: 1, month: 1
   end
 
   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 = FunctionResolver.new('minutes',
+                             [{ type: :integer, value: 7 }],
+                             current_timestamp: EXAMPLE_DATE)
     f.validate
-    assert !f.errors?, "Errors #{f.errors.inspect}"
-    value = f.call
+    assert !f.errors?
+    assert_times f.call, :datetime, min: MINUTES + 7
 
-    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 = FunctionResolver.new('minutes',
+                             [{ type: :integer, value: -2 }],
+                             current_timestamp: EXAMPLE_DATE)
     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
+    assert !f.errors?
+    assert_times f.call, :datetime, min: 59, hour: 23, mday: DAY - 1
 
-    f = FunctionResolver.new('minutes', [{ type: :integer,
-                                           value: -1440 }])
-    f.expects(:current_time).returns(test_time)
+    f = FunctionResolver.new('minutes',
+                             [{ type: :integer, value: -1440 }],
+                             current_timestamp: EXAMPLE_DATE)
     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 !f.errors?
+    assert_times f.call, :datetime, mday: DAY - 1
   end
 
   test 'hours(), same day' do
-    test_time = Time.new(2019, 4, 1, 8, 30, 20, 0)
-    tests = [1, -1, 5, -5, 12]
-
+    tests = [1, 5, 12, 23, 0]
     tests.each do |offset|
-      f = FunctionResolver.new('hours', [{ type: :integer,
-                                           value: offset }])
-      f.expects(:current_time).returns(test_time)
+      f = FunctionResolver.new('hours',
+                               [{ type: :integer, value: offset }],
+                               current_timestamp: EXAMPLE_DATE)
       f.validate
-      assert !f.errors?, "Errors #{f.errors.inspect}"
-      value = f.call
+      assert !f.errors?
+      assert_times f.call, :datetime, hour: HOURS + offset
+    end
+  end
 
-      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
+  test 'hours(), previous day' do
+    tests = [-1, -5, -12]
+    tests.each do |offset|
+      f = FunctionResolver.new('hours',
+                               [{ type: :integer, value: offset }],
+                               current_timestamp: EXAMPLE_DATE)
+      f.validate
+      assert !f.errors?
+      assert_times f.call, :datetime, hour: 24 + offset, mday: DAY - 1
     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 = FunctionResolver.new('hours',
+                             [{ type: :integer, value: 52 }],
+                             current_timestamp: EXAMPLE_DATE)
     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
+    assert !f.errors?
+    assert_times f.call, :datetime, hour: HOURS + 4, mday: 2, month: 1, year: 2022
 
     # 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 = FunctionResolver.new('hours',
+                             [{ type: :integer, value: -24 }],
+                             current_timestamp: EXAMPLE_DATE)
     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 !f.errors?
+    assert_times f.call, :datetime, mday: DAY - 1
 
     # 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 = FunctionResolver.new('hours',
+                             [{ type: :integer, value: -8760 }],
+                             current_timestamp: EXAMPLE_DATE)
     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
+    assert !f.errors?
+    assert_times f.call, :datetime, year: 2020
   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]
-    assert_equal '2012-10-27', value[:value]
+    [
+      [-1, '2021-12-30', EXAMPLE_DATE],
+      [0, '2021-12-31', EXAMPLE_DATE],
+      [1, '2022-01-01', EXAMPLE_DATE],
+      [7, '2022-01-07', EXAMPLE_DATE],
+      [0, '2022-01-01', Time.parse('2022-01-01T00:00:00-0500')]
+    ].each do |val, result, current_timestamp|
+      f = FunctionResolver.new('days',
+                               [{ type: :integer, value: val }],
+                               current_timestamp: current_timestamp)
+      f.validate
+      assert !f.errors?
+      value = f.call
+      assert_equal :date, value[:type]
+      assert_equal result, value[:value], val
+    end
   end
 
   test 'weekdays()' do
@@ -549,27 +515,25 @@ class FunctionResolverTest < Test::Unit::TestCase
   end
 
   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 }],
+                             current_timestamp: EXAMPLE_DATE)
     f.validate
-    assert !f.errors?, "Errors resolving months(): #{f.errors.inspect}"
+    assert !f.errors?
     value = f.call
     assert_equal :date, value[:type]
-
-    assert_equal '2014-04-06', value[:value]
+    assert_equal '2022-03-31', value[:value]
   end
 
   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 }],
+                             current_timestamp: EXAMPLE_DATE)
     f.validate
-    assert !f.errors?, "Errors resolving years(): #{f.errors.inspect}"
+    assert !f.errors?
     value = f.call
     assert_equal :date, value[:type]
-    assert_equal '2010-01-06', value[:value], 'negative values should go back in time'
+    assert_equal '2017-12-31', value[:value]
   end
 
   test 'year(), month(), and day()' do
@@ -821,7 +785,7 @@ class FunctionResolverTest < Test::Unit::TestCase
 
     assert_equal :function, value[:type]
     assert_equal 'cast', value[:value]
-    assert_equal(%w[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
@@ -847,7 +811,7 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :time, value[:type]
-    assert_equal '10:22:15.422804000', value[:value]
+    assert_equal '00:01:02.123456000', value[:value]
   end
 
   test 'date(datetime)' do
@@ -856,7 +820,7 @@ class FunctionResolverTest < Test::Unit::TestCase
     assert !f.errors?, "Errors #{f.errors.inspect}"
     value = f.call
     assert_equal :date, value[:type]
-    assert_equal '2013-07-26', value[:value]
+    assert_equal '2021-12-31', value[:value]
   end
 
   ###

data/test/unit/geo/record_circle_test.rb

@@ -8,8 +8,8 @@ class Sparkql::Geo::RecordRadiusTest < Test::Unit::TestCase
      "201000000000000000000000000",
      "test",
      "12.45,-96.5"].each do |bad_record_id|
-        assert !Sparkql::Geo::RecordRadius.valid_record_id?(bad_record_id),
-          "'#{bad_record_id}' should not be a valid record_id"
+       assert !Sparkql::Geo::RecordRadius.valid_record_id?(bad_record_id),
+              "'#{bad_record_id}' should not be a valid record_id"
      end
   end
 end

data/test/unit/lexer_test.rb

@@ -4,20 +4,20 @@ class LexerTest < Test::Unit::TestCase
   include Sparkql
 
   test "record the current token and current oken position" do
-      @lexer = Lexer.new "City Eq 'Fargo'"
-      token = @lexer.shift
-      assert_equal "City", @lexer.current_token_value
-      assert_equal 0, @lexer.token_index
+    @lexer = Lexer.new "City Eq 'Fargo'"
+    @lexer.shift
+    assert_equal "City", @lexer.current_token_value
+    assert_equal 0, @lexer.token_index
 
-      token = @lexer.shift
-      assert_equal " ", @lexer.current_token_value
-      assert_equal 4, @lexer.token_index
+    @lexer.shift
+    assert_equal " ", @lexer.current_token_value
+    assert_equal 4, @lexer.token_index
 
-      token = @lexer.shift
-      assert_equal "Eq", @lexer.current_token_value
-      assert_equal 5, @lexer.token_index
+    @lexer.shift
+    assert_equal "Eq", @lexer.current_token_value
+    assert_equal 5, @lexer.token_index
   end
-  
+
   def test_check_reserved_words_standard_fields
     ["OrOrOr Eq true", "Equador Eq true", "Oregon Ge 10"].each do |standard_field|
       @lexer = Lexer.new(standard_field)
@@ -27,7 +27,7 @@ class LexerTest < Test::Unit::TestCase
   end
 
   def test_standard_field_formats
-    ["City", "PostalCodePlus4", "Inb4ParserError"].each do |standard_field|
+    %w[City PostalCodePlus4 Inb4ParserError].each do |standard_field|
       @lexer = Lexer.new("#{standard_field} Eq true")
       token = @lexer.shift
       assert_equal :STANDARD_FIELD, token.first, standard_field
@@ -39,7 +39,7 @@ class LexerTest < Test::Unit::TestCase
     @lexer = Lexer.new("4PostalCodePlus4 Eq true")
     token = @lexer.shift
     assert_equal :INTEGER, token.first
-    assert_equal token[1][:value], "4" 
+    assert_equal token[1][:value], "4"
   end
 
   def test_check_reserved_words_conjunctions
@@ -62,7 +62,7 @@ class LexerTest < Test::Unit::TestCase
       assert_equal :OPERATOR, token.first, op
     end
 
-    ['Bt 1234','Bt 1234,12345'].each do |op|
+    ['Bt 1234', 'Bt 1234,12345'].each do |op|
       @lexer = Lexer.new(op)
       token = @lexer.shift
       assert_equal :RANGE_OPERATOR, token.first, op
@@ -78,7 +78,7 @@ class LexerTest < Test::Unit::TestCase
   end
 
   def test_dates_matches
-    ['2013-07-26', '1999-01-01'].each do |op|
+    %w[2013-07-26 1999-01-01].each do |op|
       @lexer = Lexer.new(op)
       token = @lexer.shift
       assert_equal :DATE, token.first, op
@@ -108,5 +108,4 @@ class LexerTest < Test::Unit::TestCase
       assert_equal :DECIMAL, token.first, op
     end
   end
-
 end