sparkql 1.2.8 → 1.3.0

data/lib/sparkql/parser_tools.rb

@@ -2,11 +2,10 @@
 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]
+  DATE_TYPES = %i[datetime date].freeze
+  NUMBER_TYPES = %i[decimal integer].freeze
+  ARITHMETIC_TYPES = %i[decimal integer field arithmetic].freeze
   GROUP = 'Group'.freeze
   NEGATION = 'Negation'.freeze
 
@@ -15,15 +14,14 @@ module Sparkql::ParserTools
     @expression_count = 0
     results = do_parse
     return if results.nil?
+
     validate_expressions results
     results
   end
 
   def next_token
     t = @lexer.shift
-    while t[0] == :SPACE or t[0] == :NEWLINE
-      t = @lexer.shift
-    end
+    t = @lexer.shift while (t[0] == :SPACE) || (t[0] == :NEWLINE)
     t
   end
 
@@ -41,20 +39,20 @@ module Sparkql::ParserTools
   end
 
   def no_field_error(field, operator)
-    tokenizer_error(:token => field,
-                    :expression => {operator: operator, conjuction: 'And', conjunction_level: 0, level: @lexer.level},
-                    :message => "Each expression must evaluate a field", :status => :fatal )
+    tokenizer_error(token: field,
+                    expression: { operator: operator, conjuction: 'And', conjunction_level: 0, level: @lexer.level },
+                    message: "Each expression must evaluate a field", status: :fatal)
   end
 
-  def tokenize_expression(field, op, val)
-    operator = get_operator(val,op) unless val.nil?
+  def tokenize_expression(field, op_token, val)
+    operator = get_operator(val, op_token) unless val.nil?
 
     field_manipulations = nil
     if field.is_a?(Hash) && field[:type] == :function
-      function = Sparkql::FunctionResolver::SUPPORTED_FUNCTIONS[field[:function_name].to_sym]
-      if function.nil?
-        tokenizer_error(:token => field[:function_name],
-          :message => "Unsupported function type", :status => :fatal )
+      unless supported_function?(field[:function_name])
+        tokenizer_error(token: field[:function_name],
+                        message: 'Unsupported function type',
+                        status: :fatal)
       end
       field_manipulations = field
       field = field[:field]
@@ -68,10 +66,10 @@ module Sparkql::ParserTools
 
     custom_field = !field.nil? && field.is_a?(String) && field.start_with?('"')
 
-    block_group = (@lexer.level == 0) ? 0 : @lexer.block_group_identifier
-    expression = {:field => field, :operator => operator, :conjunction => 'And',
-      :conjunction_level => 0, :level => @lexer.level,
-      :block_group => block_group, :custom_field => custom_field}
+    block_group = @lexer.level.zero? ? 0 : @lexer.block_group_identifier
+    expression = { field: field, operator: operator, conjunction: 'And',
+                   conjunction_level: 0, level: @lexer.level,
+                   block_group: block_group, custom_field: custom_field }
 
     if !field_manipulations.nil?
       # Keeping field_function and field_function_type for backward compatibility with datacon
@@ -89,13 +87,13 @@ module Sparkql::ParserTools
     validate_level_depth expression
     validate_field_function_depth(expression[:field_manipulations])
     if operator.nil?
-      tokenizer_error(:token => op, :expression => expression,
-        :message => "Operator not supported for this type and value string", :status => :fatal )
+      tokenizer_error(token: op_token, expression: expression,
+                      message: "Operator not supported for this type and value string", status: :fatal)
     end
     @expression_count += 1
     [expression]
   end
-  
+
   def tokenize_conjunction(exp1, conj, exp2)
     exp2.first[:conjunction] = conj
     exp2.first[:conjunction_level] = @lexer.level
@@ -107,10 +105,10 @@ module Sparkql::ParserTools
     # begins with a unary operator, and is nested, such as:
     #   Not (Not Field Eq 1)
     # In this instance we treat the outer unary as a conjunction. With any other
-    # expression this would be the case, so that should make processing 
+    # expression this would be the case, so that should make processing
     # consistent.
-    if exp.first[:unary] && @lexer.level == 0
-      exp.first[:conjunction] =  conj
+    if exp.first[:unary] && @lexer.level.zero?
+      exp.first[:conjunction] = conj
       exp.first[:conjunction_level] = @lexer.level
     else
       exp.first[:unary] = conj
@@ -119,7 +117,7 @@ module Sparkql::ParserTools
 
     exp
   end
-    
+
   def tokenize_group(expressions)
     @lexer.leveldown
     expressions
@@ -128,7 +126,7 @@ module Sparkql::ParserTools
   def tokenize_arithmetic_group(lhs)
     @lexer.leveldown
     @lexer.block_group_identifier -= 1
-    lhs = {type: :field, value: lhs} if lhs.is_a?(String)
+    lhs = { type: :field, value: lhs } if lhs.is_a?(String)
     {
       type: :arithmetic,
       op: GROUP,
@@ -137,7 +135,7 @@ module Sparkql::ParserTools
   end
 
   def tokenize_arithmetic_negation(lhs)
-    lhs = {type: :field, value: lhs} if lhs.is_a?(String)
+    lhs = { type: :field, value: lhs } if lhs.is_a?(String)
     {
       type: :arithmetic,
       op: NEGATION,
@@ -147,6 +145,7 @@ module Sparkql::ParserTools
 
   def tokenize_list(list)
     return if list.nil?
+
     validate_multiple_values list[:value]
     list[:condition] ||= list[:value]
     list
@@ -154,18 +153,18 @@ module Sparkql::ParserTools
 
   def tokenize_literal_negation(number_token)
     old_val = case number_token[:type]
-    when :integer
-      number_token[:value].to_i
-    when :decimal
-      number_token[:value].to_f
-    else
-      tokenizer_error(:token => @lexer.current_token_value,
-                      :expression => number_token,
-                      :message => "Negation is only allowed for integer and floats",
-                      :status => :fatal,
-                      :syntax => true)
-      return number_token
-    end
+              when :integer
+                number_token[:value].to_i
+              when :decimal
+                number_token[:value].to_f
+              else
+                tokenizer_error(token: @lexer.current_token_value,
+                                expression: number_token,
+                                message: "Negation is only allowed for integer and floats",
+                                status: :fatal,
+                                syntax: true)
+                return number_token
+              end
     number_token[:value] = (-1 * old_val).to_s
 
     number_token
@@ -174,43 +173,43 @@ module Sparkql::ParserTools
   def tokenize_multiple(lit1, lit2)
     final_type = lit1[:type]
     if lit1[:type] != lit2[:type]
-      final_type = coercible_types(lit1[:type],lit2[:type])
+      final_type = coercible_types(lit1[:type], lit2[:type])
       if final_type.nil?
         final_type = lit1[:type]
-        tokenizer_error(:token => @lexer.last_field, 
-                        :message => "Type mismatch in field list.",
-                        :status => :fatal, 
-                        :syntax => true)
+        tokenizer_error(token: @lexer.last_field,
+                        message: "Type mismatch in field list.",
+                        status: :fatal,
+                        syntax: true)
       end
     end
     array = Array(lit1[:value])
-    condition = lit1[:condition] || lit1[:value] 
+    condition = lit1[:condition] || lit1[:value]
     array << lit2[:value]
     {
-      :type => final_type ,
-      :value => array,
-      :multiple => "true",
-      :condition => condition + "," + (lit2[:condition] || lit2[:value])
+      type: final_type,
+      value: array,
+      multiple: "true",
+      condition: "#{condition},#{lit2[:condition] || lit2[:value]}"
     }
   end
-  
+
   def tokenize_function_args(lit1, lit2)
-    array = lit1.kind_of?(Array) ? lit1 : [lit1]
+    array = lit1.is_a?(Array) ? lit1 : [lit1]
     array << lit2
     array
   end
-  
+
   def tokenize_field_arg(field)
     if field.is_a?(String)
       {
-        :type => :field,
-        :value => field,
+        type: :field,
+        value: field
       }
     else
       field
     end
   end
-  
+
   def tokenize_function(name, f_args)
     @lexer.leveldown
     @lexer.block_group_identifier -= 1
@@ -222,24 +221,23 @@ module Sparkql::ParserTools
       condition_list << arg[:value] # Needs to be pure string value
       arg[:value] = escape_value(arg)
     end
-    resolver = Sparkql::FunctionResolver.new(name, args)
-    
+    resolver = function_resolver(name, args)
     resolver.validate
-    if(resolver.errors?)
-      tokenizer_error(:token => @lexer.last_field, 
-                      :message => "Error parsing function #{resolver.errors.join(',')}",
-                      :status => :fatal, 
-                      :syntax => true)    
-      return nil
+    if resolver.errors?
+      tokenizer_error(token: @lexer.last_field,
+                      message: "Error parsing function #{resolver.errors.join(',')}",
+                      status: :fatal,
+                      syntax: true)
+      nil
     else
-      result = resolver.call()
-      result.nil? ? result : result.merge(:condition => "#{name}(#{condition_list.join(',')})")
+      result = resolver.call
+      result.nil? ? result : result.merge(condition: "#{name}(#{condition_list.join(',')})")
     end
   end
 
   def tokenize_arithmetic(lhs, operator, rhs)
-    lhs = {type: :field, value: lhs} if lhs.is_a?(String)
-    rhs = {type: :field, value: rhs} if rhs.is_a?(String)
+    lhs = { type: :field, value: lhs } if lhs.is_a?(String)
+    rhs = { type: :field, value: rhs } if rhs.is_a?(String)
 
     arithmetic_error?(lhs)
     arithmetic_error?(rhs)
@@ -253,11 +251,11 @@ module Sparkql::ParserTools
 
   def arithmetic_error?(side)
     side_type = side[:type] == :function ? side[:return_type] : side[:type]
-    return false unless (!ARITHMETIC_TYPES.include?(side_type) || !ARITHMETIC_TYPES.include?(side_type))
+    return false if ARITHMETIC_TYPES.include?(side_type)
 
-    compile_error(:token => side[:value], :expression => side,
-          :message => "Error attempting arithmetic with type: #{side_type}",
-          :status => :fatal, :syntax => false, :constraint => true )
+    compile_error(token: side[:value], expression: side,
+                  message: "Error attempting arithmetic with type: #{side_type}",
+                  status: :fatal, syntax: false, constraint: true)
     true
   end
 
@@ -267,47 +265,47 @@ module Sparkql::ParserTools
     exp
   end
 
-  def add_fold(n1, n2)
-    return if arithmetic_error?(n1) || arithmetic_error?(n2)
+  def add_fold(node1, node2)
+    return if arithmetic_error?(node1) || arithmetic_error?(node2)
 
-    value = escape_arithmetic_value(n1) + escape_arithmetic_value(n2)
-    { type: arithmetic_type(n1, n2), value: unescape_arithmetic(value) }
+    value = escape_arithmetic_value(node1) + escape_arithmetic_value(node2)
+    { type: arithmetic_type(node1, node2), value: unescape_arithmetic(value) }
   end
 
-  def sub_fold(n1, n2)
-    return if arithmetic_error?(n1) || arithmetic_error?(n2)
+  def sub_fold(node1, node2)
+    return if arithmetic_error?(node1) || arithmetic_error?(node2)
 
-    value = escape_arithmetic_value(n1) - escape_arithmetic_value(n2)
-    { type: arithmetic_type(n1, n2), value: unescape_arithmetic(value) }
+    value = escape_arithmetic_value(node1) - escape_arithmetic_value(node2)
+    { type: arithmetic_type(node1, node2), value: unescape_arithmetic(value) }
   end
 
-  def mul_fold(n1, n2)
-    return if arithmetic_error?(n1) || arithmetic_error?(n2)
+  def mul_fold(node1, node2)
+    return if arithmetic_error?(node1) || arithmetic_error?(node2)
 
-    value = escape_arithmetic_value(n1) * escape_arithmetic_value(n2)
-    { type: arithmetic_type(n1, n2), value: unescape_arithmetic(value) }
+    value = escape_arithmetic_value(node1) * escape_arithmetic_value(node2)
+    { type: arithmetic_type(node1, node2), value: unescape_arithmetic(value) }
   end
 
-  def div_fold(n1, n2)
-    return if arithmetic_error?(n1) ||
-      arithmetic_error?(n2) ||
-      zero_error?(n2)
+  def div_fold(node1, node2)
+    return if arithmetic_error?(node1) ||
+              arithmetic_error?(node2) ||
+              zero_error?(node2)
 
-    value = escape_arithmetic_value(n1) / escape_arithmetic_value(n2)
-    { type: arithmetic_type(n1, n2), value: unescape_arithmetic(value) }
+    value = escape_arithmetic_value(node1) / escape_arithmetic_value(node2)
+    { type: arithmetic_type(node1, node2), value: unescape_arithmetic(value) }
   end
 
-  def mod_fold(n1, n2)
-    return if arithmetic_error?(n1) ||
-      arithmetic_error?(n2) ||
-      zero_error?(n2)
+  def mod_fold(node1, node2)
+    return if arithmetic_error?(node1) ||
+              arithmetic_error?(node2) ||
+              zero_error?(node2)
 
-    value = escape_arithmetic_value(n1) % escape_arithmetic_value(n2)
-    { type: arithmetic_type(n1, n2), value: unescape_arithmetic(value) }
+    value = escape_arithmetic_value(node1) % escape_arithmetic_value(node2)
+    { type: arithmetic_type(node1, node2), value: unescape_arithmetic(value) }
   end
 
   def arithmetic_type(num1, num2)
-    if (num1[:type] == :decimal || num2[:type] == :decimal)
+    if num1[:type] == :decimal || num2[:type] == :decimal
       :decimal
     else
       :integer
@@ -317,7 +315,7 @@ module Sparkql::ParserTools
   def escape_arithmetic_value(expression)
     case expression[:type]
     when :decimal
-      BigDecimal.new(expression[:value])
+      BigDecimal(expression[:value])
     else
       escape_value(expression)
     end
@@ -332,71 +330,71 @@ module Sparkql::ParserTools
   end
 
   def zero_error?(number)
-    return unless escape_value(number) == 0
+    return unless escape_value(number).zero?
 
-    compile_error(:token => "#{number[:value]}", :expression => number,
-          :message => "Error attempting to divide by zero",
-          :status => :fatal, :syntax => false, :constraint => true )
+    compile_error(token: (number[:value]).to_s, expression: number,
+                  message: "Error attempting to divide by zero",
+                  status: :fatal, syntax: false, constraint: true)
   end
 
-  def on_error(error_token_id, error_value, value_stack)
+  def on_error(error_token_id, _error_value, _value_stack)
     token_name = token_to_str(error_token_id)
     token_name.downcase!
-    tokenizer_error(:token => @lexer.current_token_value, 
-                    :message => "Error parsing token #{token_name}",
-                    :status => :fatal, 
-                    :syntax => true)    
-  end  
+    tokenizer_error(token: @lexer.current_token_value,
+                    message: "Error parsing token #{token_name}",
+                    status: :fatal,
+                    syntax: true)
+  end
 
-  def validate_level_depth expression
+  def validate_level_depth(expression)
     if @lexer.level > max_level_depth
-      compile_error(:token => "(", :expression => expression,
-            :message => "You have exceeded the maximum nesting level.  Please nest no more than #{max_level_depth} levels deep.",
-            :status => :fatal, :syntax => false, :constraint => true )
+      compile_error(token: "(", expression: expression,
+                    message: "You have exceeded the maximum nesting level.  Please nest no more than #{max_level_depth} levels deep.",
+                    status: :fatal, syntax: false, constraint: true)
     end
   end
 
   def validate_field_function_depth(expression)
     if nested_function_depth(expression) > max_function_depth
-      compile_error(:token => "(", :expression => expression,
-            :message => "You have exceeded the maximum function nesting level.  Please nest no more than #{max_function_depth} levels deep.",
-            :status => :fatal, :syntax => false, :constraint => true )
+      compile_error(token: "(", expression: expression,
+                    message: "You have exceeded the maximum function nesting level.  Please nest no more than #{max_function_depth} levels deep.",
+                    status: :fatal, syntax: false, constraint: true)
     end
   end
 
-  def validate_expressions results
-    if results.size > max_expressions 
-      compile_error(:token => results[max_expressions][:field], :expression => results[max_expressions],
-            :message => "You have exceeded the maximum expression count.  Please limit to no more than #{max_expressions} expressions in a filter.",
-            :status => :fatal, :syntax => false, :constraint => true )
+  def validate_expressions(results)
+    if results.size > max_expressions
+      compile_error(token: results[max_expressions][:field], expression: results[max_expressions],
+                    message: "You have exceeded the maximum expression count.  Please limit to no more than #{max_expressions} expressions in a filter.",
+                    status: :fatal, syntax: false, constraint: true)
       results.slice!(max_expressions..-1)
     end
   end
-  
-  def validate_multiple_values values
+
+  def validate_multiple_values(values)
     values = Array(values)
-    if values.size > max_values 
-      compile_error(:token => values[max_values],
-            :message => "You have exceeded the maximum value count.  Please limit to #{max_values} values in a single expression.",
-            :status => :fatal, :syntax => false, :constraint => true )
+    if values.size > max_values
+      compile_error(token: values[max_values],
+                    message: "You have exceeded the maximum value count.  Please limit to #{max_values} values in a single expression.",
+                    status: :fatal, syntax: false, constraint: true)
       values.slice!(max_values..-1)
     end
   end
-  
-  def validate_multiple_arguments args
+
+  def validate_multiple_arguments(args)
     args = Array(args)
-    if args.size > max_values 
-      compile_error(:token => args[max_values],
-            :message => "You have exceeded the maximum parameter count.  Please limit to #{max_values} parameters to a single function.",
-            :status => :fatal, :syntax => false, :constraint => true )
+    if args.size > max_values
+      compile_error(token: args[max_values],
+                    message: "You have exceeded the maximum parameter count.  Please limit to #{max_values} parameters to a single function.",
+                    status: :fatal, syntax: false, constraint: true)
       args.slice!(max_values..-1)
     end
   end
-  
-  # If both types support coercion with eachother, always selects the highest 
+
+  # If both types support coercion with eachother, always selects the highest
   # precision type to return as a reflection of the two. Any type that doesn't
   # support coercion with the other type returns nil
-  def coercible_types type1, type2
+  def coercible_types(type1, type2)
     if DATE_TYPES.include?(type1) && DATE_TYPES.include?(type2)
       DATE_TYPES.first
     elsif NUMBER_TYPES.include?(type1) && NUMBER_TYPES.include?(type2)
@@ -413,13 +411,13 @@ module Sparkql::ParserTools
     queue = []
     queue.push(expression)
 
-    while true
+    loop do
       count = queue.size
-      return height if count == 0
+      return height if count.zero?
 
       height += 1
 
-      while count > 0
+      while count.positive?
         node = queue.shift
         node[:args].each do |child|
           queue.push(child) if child[:type] == :function
@@ -428,4 +426,26 @@ module Sparkql::ParserTools
       end
     end
   end
+
+  def function_resolver(function_name, function_args = [])
+    Sparkql::FunctionResolver.new(function_name,
+                                  function_args,
+                                  current_timestamp: current_timestamp)
+  end
+
+  def supported_function?(function_name)
+    !lookup_function(function_name).nil?
+  end
+
+  def lookup_function(function_name)
+    Sparkql::FunctionResolver.lookup(function_name)
+  end
+
+  def current_timestamp
+    @current_timestamp ||= Time.now
+  end
+
+  def offset
+    @offset ||= current_timestamp.strftime('%:z')
+  end
 end

data/lib/sparkql/token.rb

@@ -1,31 +1,31 @@
 module Sparkql::Token
-  SPACE = /[\t ]+/
-  NEWLINE = /\r\n|\n\r|\r|\n/
-  LPAREN = /\(/
-  RPAREN = /\)/
-  KEYWORD = /[A-Za-z]+/
+  SPACE = /[\t ]+/.freeze
+  NEWLINE = /\r\n|\n\r|\r|\n/.freeze
+  LPAREN = /\(/.freeze
+  RPAREN = /\)/.freeze
+  KEYWORD = /[A-Za-z]+/.freeze
 
-  ADD = 'Add'
-  SUB = 'Sub'
+  ADD = 'Add'.freeze
+  SUB = 'Sub'.freeze
 
-  MUL = 'Mul'
-  DIV = 'Div'
-  MOD = 'Mod'
+  MUL = 'Mul'.freeze
+  DIV = 'Div'.freeze
+  MOD = 'Mod'.freeze
 
-  STANDARD_FIELD = /[A-Z]+[A-Za-z0-9]*/
-  CUSTOM_FIELD = /^(\"([^$."][^."]+)\".\"([^$."][^."]*)\")/
-  INTEGER = /^\-?[0-9]+/
-  DECIMAL = /^\-?[0-9]+\.[0-9]+([Ee]-?[0-9]{1,2})?/
-  CHARACTER = /^'([^'\\]*(\\.[^'\\]*)*)'/
-  DATE = /^[0-9]{4}\-[0-9]{2}\-[0-9]{2}/
-  TIME = /^[0-9]{2}\:[0-9]{2}((\:[0-9]{2})(\.[0-9]{1,50})?)?/
-  DATETIME = /^[0-9]{4}\-[0-9]{2}\-[0-9]{2}T[0-9]{2}\:[0-9]{2}((\:[0-9]{2})(\.[0-9]{1,50})?)?(((\+|-)[0-9]{2}\:?[0-9]{2})|Z)?/
-  BOOLEAN = /^true|false/
-  NULL = /NULL|null|Null/
+  STANDARD_FIELD = /[A-Z]+[A-Za-z0-9]*/.freeze
+  CUSTOM_FIELD = /^("([^$."][^."]+)"."([^$."][^."]*)")/.freeze
+  INTEGER = /^-?[0-9]+/.freeze
+  DECIMAL = /^-?[0-9]+\.[0-9]+([Ee]-?[0-9]{1,2})?/.freeze
+  CHARACTER = /^'([^'\\]*(\\.[^'\\]*)*)'/.freeze
+  DATE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}/.freeze
+  TIME = /^[0-9]{2}:[0-9]{2}((:[0-9]{2})(\.[0-9]{1,50})?)?/.freeze
+  DATETIME = /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}((:[0-9]{2})(\.[0-9]{1,50})?)?(((\+|-)[0-9]{2}:?[0-9]{2})|Z)?/.freeze
+  BOOLEAN = /^true|false/.freeze
+  NULL = /NULL|null|Null/.freeze
   # Reserved words
-  RANGE_OPERATOR = 'Bt'
-  EQUALITY_OPERATORS = ['Eq','Ne']
-  OPERATORS = ['Gt','Ge','Lt','Le'] + EQUALITY_OPERATORS
-  UNARY_CONJUNCTIONS = ['Not']
-  CONJUNCTIONS = ['And','Or']
+  RANGE_OPERATOR = 'Bt'.freeze
+  EQUALITY_OPERATORS = %w[Eq Ne].freeze
+  OPERATORS = %w[Gt Ge Lt Le] + EQUALITY_OPERATORS
+  UNARY_CONJUNCTIONS = ['Not'].freeze
+  CONJUNCTIONS = %w[And Or].freeze
 end

data/lib/sparkql/version.rb

@@ -1,3 +1,3 @@
 module Sparkql
-  VERSION = File.read(File.dirname(__FILE__) + "/../../VERSION").chomp
+  VERSION = File.read("#{File.dirname(__FILE__)}/../../VERSION").chomp
 end

data/sparkql.gemspec

@@ -27,6 +27,6 @@ Gem::Specification.new do |s|
   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 'rake', ">=12.3.3"
   s.add_development_dependency 'test-unit', '~> 2.1.0'
 end

data/test/unit/errors_test.rb

@@ -10,21 +10,20 @@ class ParserTest < Test::Unit::TestCase
   end
 
   def test_error_constraint
-    errors = ParserError.new(:constraint => true, :syntax => false)
+    errors = ParserError.new(constraint: true, syntax: false)
     assert !errors.syntax?
     assert errors.constraint?
   end
-  
+
   def test_process_fatal_errors
-    p = ErrorsProcessor.new(ParserError.new(:status => :fatal))
+    p = ErrorsProcessor.new(ParserError.new(status: :fatal))
     assert p.fatal_errors?
     assert !p.dropped_errors?
   end
 
   def test_process_dropped_errors
-    p = ErrorsProcessor.new(ParserError.new(:status => :dropped))
+    p = ErrorsProcessor.new(ParserError.new(status: :dropped))
     assert p.dropped_errors?
     assert !p.fatal_errors?
   end
-
 end