dentaku 2.0.5 → 2.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91e1c068c1ad4f4399eece3c6ac66ab9c17591cf
-  data.tar.gz: 2df26e17bb06fa076d30e56e880b5d5797df1dc3
+  metadata.gz: 813c0e0ea4c6a021ca324515d26386d2f2f28962
+  data.tar.gz: 943958582e98916af345553a343b261b978c97c5
 SHA512:
-  metadata.gz: 83222ea1e9505e2cdfa692f37142776fdb7be70cf39098d536b6a0c85958272421800f04e7876f9d7ba39bfe4d3eb19a49f2efa5b631b0ecddea4ed858c3e4ca
-  data.tar.gz: 32dc26ce15c748d7091c775356735fabf5abdf3f391db3407b663769e56c361247478edae5f3b3dc725aa97cb44b3a635e5212b293dc97af9940dedab83852a8
+  metadata.gz: d281ac5672cb9badc8ba74033d5624bd2e23d12f37785a6fc47595be0de51c8da9a2419eb0701de273e6ed710212988f47a16a72fef9fcbc119a8c39b38ebad4
+  data.tar.gz: 8f3ca27e26d5a603c99d2473a3115fb87c00407127b7d1613f0c0634057f37318583de7a7f8192d47db0ea8236648e916ea6dbc6084add0b591b4939e95c48f1

data/.travis.yml

@@ -1,4 +1,7 @@
 language: ruby
+before_install:
+  - gem update --system
+  - gem update bundler
 rvm:
   - 1.9.3
   - 2.0.0

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Change Log
 
+## [Unreleased]
+
+## [v2.0.6] 2016-01-26
+- support array parameters for external functions
+- support case statements
+- support precision for `ROUNDUP` and `ROUNDDOWN` functions
+- prevent errors from corrupting calculator memory
+
 ## [v2.0.5] 2015-09-03
 - fix bug with detecting unbound nodes
 - silence warnings
@@ -90,6 +98,8 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[Unreleased]:  https://github.com/rubysolo/dentaku/compare/v2.0.6...HEAD
+[v2.0.6]:  https://github.com/rubysolo/dentaku/compare/v2.0.5...v2.0.6
 [v2.0.5]:  https://github.com/rubysolo/dentaku/compare/v2.0.4...v2.0.5
 [v2.0.4]:  https://github.com/rubysolo/dentaku/compare/v2.0.3...v2.0.4
 [v2.0.3]:  https://github.com/rubysolo/dentaku/compare/v2.0.1...v2.0.3

data/Gemfile

@@ -2,3 +2,8 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in dentaku.gemspec
 gemspec
+
+if RUBY_VERSION.to_f >= 2.0 && RUBY_ENGINE == 'ruby'
+  gem 'pry-byebug'
+  gem 'pry-stack_explorer'
+end

data/README.md

@@ -260,21 +260,7 @@ THANKS
 
 Big thanks to [ElkStone Basements](http://www.elkstonebasements.com/) for
 allowing me to extract and open source this code.  Thanks also to all the
-contributors:
-
-* [0xCCD](https://github.com/0xCCD)
-* [AlexeyMK](https://github.com/AlexeyMK)
-* [antonversal](https://github.com/antonversal)
-* [arnaudl](https://github.com/arnaudl)
-* [bernardofire](https://github.com/bernardofire)
-* [brixen](https://github.com/brixen)
-* [CraigCottingham](https://github.com/CraigCottingham)
-* [glanotte](https://github.com/glanotte)
-* [jasonhutchens](https://github.com/jasonhutchens)
-* [jmangs](https://github.com/jmangs)
-* [mvbrocato](https://github.com/mvbrocato)
-* [schneidmaster](https://github.com/schneidmaster)
-* [thbar](https://github.com/thbar) / [BoxCar](https://www.boxcar.io)
+[contributors](https://github.com/rubysolo/dentaku/graphs/contributors)!
 
 
 LICENSE

data/lib/dentaku/ast.rb

@@ -9,6 +9,7 @@ require_relative './ast/negation'
 require_relative './ast/comparators'
 require_relative './ast/combinators'
 require_relative './ast/grouping'
+require_relative './ast/case'
 require_relative './ast/functions/if'
 require_relative './ast/functions/max'
 require_relative './ast/functions/min'

data/lib/dentaku/ast/case.rb

@@ -0,0 +1,52 @@
+require_relative './case/case_conditional'
+require_relative './case/case_when'
+require_relative './case/case_then'
+require_relative './case/case_switch_variable'
+require_relative './case/case_else'
+
+module Dentaku
+  module AST
+    class Case < Node
+      def initialize(*nodes)
+        @switch = nodes.shift
+
+        unless @switch.is_a?(AST::CaseSwitchVariable)
+          raise 'Case missing switch variable'
+        end
+
+        @conditions = nodes
+
+        @else = @conditions.pop if @conditions.last.is_a?(AST::CaseElse)
+
+        @conditions.each do |condition|
+          unless condition.is_a?(AST::CaseConditional)
+            raise "#{condition} is not a CaseConditional"
+          end
+        end
+      end
+
+      def value(context={})
+        switch_value = @switch.value(context)
+        @conditions.each do |condition|
+          if condition.when.value(context) == switch_value
+            return condition.then.value(context)
+          end
+        end
+
+        if @else
+          return @else.value(context)
+        else
+          raise "No block matched the switch value '#{switch_value}'"
+        end
+      end
+
+      def dependencies(context={})
+        # TODO: should short-circuit
+        @switch.dependencies(context) +
+          @conditions.flat_map do |condition|
+            condition.dependencies(context)
+          end
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case/case_conditional.rb

@@ -0,0 +1,23 @@
+module Dentaku
+  module AST
+    class CaseConditional < Node
+      attr_reader :when,
+                  :then
+
+      def initialize(when_statement, then_statement)
+        @when = when_statement
+        unless @when.is_a?(AST::CaseWhen)
+          raise 'Expected first argument to be a CaseWhen'
+        end
+        @then = then_statement
+        unless @then.is_a?(AST::CaseThen)
+          raise 'Expected second argument to be a CaseThen'
+        end
+      end
+
+      def dependencies(context={})
+        @when.dependencies(context) + @then.dependencies(context)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case/case_else.rb

@@ -0,0 +1,21 @@
+module Dentaku
+  module AST
+    class CaseElse < Node
+      def self.arity
+        1
+      end
+
+      def initialize(node)
+        @node = node
+      end
+
+      def value(context={})
+        @node.value(context)
+      end
+
+      def dependencies(context={})
+        @node.dependencies(context)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case/case_switch_variable.rb

@@ -0,0 +1,21 @@
+module Dentaku
+  module AST
+    class CaseSwitchVariable < Node
+      def initialize(node)
+        @node = node
+      end
+
+      def value(context={})
+        @node.value(context)
+      end
+
+      def dependencies(context={})
+        @node.dependencies(context)
+      end
+
+      def self.arity
+        1
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case/case_then.rb

@@ -0,0 +1,21 @@
+module Dentaku
+  module AST
+    class CaseThen < Node
+      def self.arity
+        1
+      end
+
+      def initialize(node)
+        @node = node
+      end
+
+      def value(context={})
+        @node.value(context)
+      end
+
+      def dependencies(context={})
+        @node.dependencies(context)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case/case_when.rb

@@ -0,0 +1,21 @@
+module Dentaku
+  module AST
+    class CaseWhen < Operation
+      def self.arity
+        1
+      end
+
+      def initialize(node)
+        @node = node
+      end
+
+      def value(context={})
+        @node.value(context)
+      end
+
+      def dependencies(context={})
+        @node.dependencies(context)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/function.rb

@@ -34,7 +34,7 @@ module Dentaku
           end
 
           def value(context={})
-            args = @args.flat_map { |a| a.value(context) }
+            args = @args.map { |a| a.value(context) }
             self.class.implementation.call(*args)
           end
 

data/lib/dentaku/ast/functions/rounddown.rb

@@ -1,5 +1,7 @@
 require_relative '../function'
 
-Dentaku::AST::Function.register(:rounddown, :numeric, ->(numeric) {
-  numeric.floor
+Dentaku::AST::Function.register(:rounddown, :numeric, ->(numeric, precision=0) {
+  tens = 10.0**precision
+  result = (numeric * tens).floor / tens
+  precision <= 0 ? result.to_i : result
 })

data/lib/dentaku/ast/functions/roundup.rb

@@ -1,5 +1,7 @@
 require_relative '../function'
 
-Dentaku::AST::Function.register(:roundup, :numeric, ->(numeric) {
-  numeric.ceil
+Dentaku::AST::Function.register(:roundup, :numeric, ->(numeric, precision=0) {
+  tens = 10.0**precision
+  result = (numeric * tens).ceil / tens
+  precision <= 0 ? result.to_i : result
 })

data/lib/dentaku/calculator.rb

@@ -71,9 +71,14 @@ module Dentaku
       end
 
       if block_given?
-        result = yield
-        @memory = restore
-        return result
+        begin
+          result = yield
+          @memory = restore
+          return result
+        rescue => e
+          @memory = restore
+          raise e
+        end
       end
 
       self

data/lib/dentaku/parser.rb

@@ -4,11 +4,11 @@ module Dentaku
   class Parser
     attr_reader :input, :output, :operations, :arities
 
-    def initialize(tokens)
+    def initialize(tokens, options={})
       @input      = tokens.dup
       @output     = []
-      @operations = []
-      @arities    = []
+      @operations = options.fetch(:operations, [])
+      @arities    = options.fetch(:arities, [])
     end
 
     def get_args(count)
@@ -58,6 +58,90 @@ module Dentaku
           arities.push 0
           operations.push function(token)
 
+        when :case
+          case token.value
+          when :open
+            # special handling for case nesting: strip out inner case
+            # statements and parse their AST segments recursively
+            if operations.include?(AST::Case)
+              last_case_close_index = nil
+              first_nested_case_close_index = nil
+              input.each_with_index do |token, index|
+                first_nested_case_close_index = last_case_close_index
+                if token.category == :case && token.value == :close
+                  last_case_close_index = index
+                end
+              end
+              inner_case_inputs = input.slice!(0..first_nested_case_close_index)
+              subparser = Parser.new(
+                inner_case_inputs,
+                operations: [AST::Case],
+                arities: [0]
+              )
+              subparser.parse
+              output.concat(subparser.output)
+            else
+              operations.push AST::Case
+              arities.push(0)
+            end
+          when :close
+            if operations[1] == AST::CaseThen
+              while operations.last != AST::Case
+                consume
+              end
+
+              operations.push(AST::CaseConditional)
+              consume(2)
+              arities[-1] += 1
+            elsif operations[1] == AST::CaseElse
+              while operations.last != AST::Case
+                consume
+              end
+
+              arities[-1] += 1
+            end
+
+            unless operations.count == 1 && operations.last == AST::Case
+              fail "Unprocessed token #{ token.value }"
+            end
+            consume(arities.pop.succ)
+          when :when
+            if operations[1] == AST::CaseThen
+              while ![AST::CaseWhen, AST::Case].include?(operations.last)
+                consume
+              end
+              operations.push(AST::CaseConditional)
+              consume(2)
+              arities[-1] += 1
+            elsif operations.last == AST::Case
+              operations.push(AST::CaseSwitchVariable)
+              consume
+            end
+
+            operations.push(AST::CaseWhen)
+          when :then
+            if operations[1] == AST::CaseWhen
+              while ![AST::CaseThen, AST::Case].include?(operations.last)
+                consume
+              end
+            end
+            operations.push(AST::CaseThen)
+          when :else
+            if operations[1] == AST::CaseThen
+              while operations.last != AST::Case
+                consume
+              end
+
+              operations.push(AST::CaseConditional)
+              consume(2)
+              arities[-1] += 1
+            end
+
+            operations.push(AST::CaseElse)
+          else
+            fail "Unknown case token #{ token.value }"
+          end
+
         when :grouping
           case token.value
           when :open

data/lib/dentaku/token_scanner.rb

@@ -33,6 +33,7 @@ module Dentaku
           :negate,
           :operator,
           :grouping,
+          :case_statement,
           :comparator,
           :combinator,
           :boolean,
@@ -100,6 +101,11 @@ module Dentaku
         new(:grouping, '\(|\)|,', lambda { |raw| names[raw] })
       end
 
+      def case_statement
+        names = { open: 'case', close: 'end', then: 'then', when: 'when', else: 'else' }.invert
+        new(:case, '(case|end|then|when|else)\b', lambda { |raw| names[raw.downcase] })
+      end
+
       def comparator
         names = { le: '<=', ge: '>=', ne: '!=', lt: '<', gt: '>', eq: '=' }.invert
         alternate = { ne: '<>', eq: '==' }.invert

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "2.0.5"
+  VERSION = "2.0.6"
 end

data/spec/ast/case_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'dentaku/ast/operation'
+require 'dentaku/ast/logical'
+require 'dentaku/ast/identifier'
+require 'dentaku/ast/arithmetic'
+require 'dentaku/ast/case'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Case do
+  let!(:one) { Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 1) }
+  let!(:two)  { Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 2) }
+  let!(:apple) do
+    Dentaku::AST::Logical.new Dentaku::Token.new(:string, 'apple')
+  end
+  let!(:banana) do
+    Dentaku::AST::Logical.new Dentaku::Token.new(:string, 'banana')
+  end
+  let!(:identifier) do
+    Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, :fruit))
+  end
+  let!(:switch) { Dentaku::AST::CaseSwitchVariable.new(identifier) }
+
+  let!(:when1) { Dentaku::AST::CaseWhen.new(apple) }
+  let!(:then1) { Dentaku::AST::CaseThen.new(one) }
+  let!(:conditional1) { Dentaku::AST::CaseConditional.new(when1, then1) }
+
+  let!(:when2) { Dentaku::AST::CaseWhen.new(banana) }
+  let!(:then2) { Dentaku::AST::CaseThen.new(two) }
+  let!(:conditional2) { Dentaku::AST::CaseConditional.new(when2, then2) }
+
+  describe '#value' do
+    it 'raises an exception if there is no switch variable' do
+      expect { described_class.new(conditional1, conditional2) }
+        .to raise_error('Case missing switch variable')
+    end
+
+    it 'raises an exception if a non-conditional is passed' do
+      expect { described_class.new(switch, conditional1, when2) }
+        .to raise_error(/is not a CaseConditional/)
+    end
+
+    it 'tests each conditional against the switch variable' do
+      node = described_class.new(switch, conditional1, conditional2)
+      expect(node.value(fruit: 'banana')).to eq(2)
+    end
+
+    it 'raises an exception if the conditional is not matched' do
+      node = described_class.new(switch, conditional1, conditional2)
+      expect { node.value(fruit: 'orange') }
+        .to raise_error("No block matched the switch value 'orange'")
+    end
+
+    it 'uses the else value if provided and conditional is not matched' do
+      three = Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 3)
+      else_statement = Dentaku::AST::CaseElse.new(three)
+      node = described_class.new(
+        switch,
+        conditional1,
+        conditional2,
+        else_statement)
+      expect(node.value(fruit: 'orange')).to eq(3)
+    end
+  end
+
+  describe '#dependencies' do
+    let!(:tax) do
+      Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, :tax))
+    end
+    let!(:addition) { Dentaku::AST::Addition.new(two, tax) }
+    let!(:when2) { Dentaku::AST::CaseWhen.new(banana) }
+    let!(:then2) { Dentaku::AST::CaseThen.new(addition) }
+    let!(:conditional2) { Dentaku::AST::CaseConditional.new(when2, then2) }
+
+    it 'gathers dependencies from switch and conditionals' do
+      node = described_class.new(switch, conditional1, conditional2)
+      expect(node.dependencies).to eq([:fruit, :tax])
+    end
+  end
+end

data/spec/calculator_spec.rb

@@ -130,6 +130,17 @@ describe Dentaku::Calculator do
       expect(calculator.solve(expressions) { :foo })
         .to eq(more_apples: :foo)
     end
+
+    it "solves remainder of expressions with unbound variable" do
+      calculator.store(peaches: 1, oranges: 1)
+      expressions = { more_apples: "apples + 1", more_peaches: "peaches + 1" }
+      result = calculator.solve(expressions)
+      expect(calculator.memory).to eq("peaches" => 1, "oranges" => 1)
+      expect(result).to eq(
+        more_apples: :undefined,
+        more_peaches: 2
+      )
+    end
   end
 
   it 'evaluates a statement with no variables' do
@@ -227,6 +238,104 @@ describe Dentaku::Calculator do
       result = calculator.evaluate('number_of_sheets / if(multi_color, sheets_per_minute_color, sheets_per_minute_black)')
       expect(result).to eq(5)
     end
+
+    describe 'roundup' do
+      it 'should work with one argument' do
+        expect(calculator.evaluate('roundup(1.234)')).to eq(2)
+      end
+
+      it 'should accept second precision argument like in Office formula' do
+        expect(calculator.evaluate('roundup(1.234, 2)')).to eq(1.24)
+      end
+    end
+
+    describe 'rounddown' do
+      it 'should work with one argument' do
+        expect(calculator.evaluate('rounddown(1.234)')).to eq(1)
+      end
+
+      it 'should accept second precision argument like in Office formula' do
+        expect(calculator.evaluate('rounddown(1.234, 2)')).to eq(1.23)
+      end
+    end
+  end
+
+  describe 'case statements' do
+    it 'handles complex then statements' do
+      formula = <<-FORMULA
+      CASE fruit
+      WHEN 'apple'
+        THEN (1 * quantity)
+      WHEN 'banana'
+        THEN (2 * quantity)
+      END
+      FORMULA
+      expect(calculator.evaluate(formula, quantity: 3, fruit: 'apple')).to eq(3)
+      expect(calculator.evaluate(formula, quantity: 3, fruit: 'banana')).to eq(6)
+    end
+
+    it 'handles complex when statements' do
+      formula = <<-FORMULA
+      CASE number
+      WHEN (2 * 2)
+        THEN 1
+      WHEN (2 * 3)
+        THEN 2
+      END
+      FORMULA
+      expect(calculator.evaluate(formula, number: 4)).to eq(1)
+      expect(calculator.evaluate(formula, number: 6)).to eq(2)
+    end
+
+    it 'throws an exception when no match and there is no default value' do
+      formula = <<-FORMULA
+      CASE number
+      WHEN 42
+        THEN 1
+      END
+      FORMULA
+      expect { calculator.evaluate(formula, number: 2) }
+        .to raise_error("No block matched the switch value '2'")
+    end
+
+    it 'handles a default else statement' do
+      formula = <<-FORMULA
+      CASE fruit
+      WHEN 'apple'
+        THEN 1 * quantity
+      WHEN 'banana'
+        THEN 2 * quantity
+      ELSE
+        3 * quantity
+      END
+      FORMULA
+      expect(calculator.evaluate(formula, quantity: 1, fruit: 'banana')).to eq(2)
+      expect(calculator.evaluate(formula, quantity: 1, fruit: 'orange')).to eq(3)
+    end
+
+    it 'handles nested case statements' do
+      formula = <<-FORMULA
+      CASE fruit
+      WHEN 'apple'
+        THEN 1 * quantity
+      WHEN 'banana'
+        THEN
+        CASE quantity
+        WHEN 1 THEN 2
+        WHEN 10 THEN
+          CASE type
+          WHEN 'organic' THEN 5
+          END
+        END
+      END
+      FORMULA
+      value = calculator.evaluate(
+        formula,
+        type: 'organic',
+        quantity: 10,
+        fruit: 'banana')
+      expect(value).to eq(5)
+    end
   end
 
   describe 'math functions' do

data/spec/external_function_spec.rb

@@ -38,6 +38,19 @@ describe Dentaku::Calculator do
       it 'includes SMALLEST' do
         expect(with_external_funcs.evaluate('SMALLEST(8,6,7,5,3,0,9)')).to eq(0)
       end
+
+      it 'supports array parameters' do
+        calculator = described_class.new
+        calculator.add_function(
+          :includes,
+          :logical,
+          ->(haystack, needle) {
+            haystack.include?(needle)
+          }
+        )
+
+        expect(calculator.evaluate("INCLUDES(list, 2)", list: [1,2,3])).to eq(true)
+      end
     end
   end
 end

data/spec/parser_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'dentaku/token'
 require 'dentaku/parser'
 
 describe Dentaku::Parser do
@@ -94,4 +95,32 @@ describe Dentaku::Parser do
     node  = described_class.new([d_true, d_and, d_false]).parse
     expect(node.value).to eq false
   end
+
+  it 'evaluates a case statement' do
+    case_start  = Dentaku::Token.new(:case, :open)
+    x     = Dentaku::Token.new(:identifier, :x)
+    case_when1 = Dentaku::Token.new(:case, :when)
+    one  = Dentaku::Token.new(:numeric, 1)
+    case_then1 = Dentaku::Token.new(:case, :then)
+    two  = Dentaku::Token.new(:numeric, 2)
+    case_when2 = Dentaku::Token.new(:case, :when)
+    three  = Dentaku::Token.new(:numeric, 3)
+    case_then2 = Dentaku::Token.new(:case, :then)
+    four  = Dentaku::Token.new(:numeric, 4)
+    case_close  = Dentaku::Token.new(:case, :close)
+
+    node  = described_class.new(
+      [case_start,
+       x,
+       case_when1,
+       one,
+       case_then1,
+       two,
+       case_when2,
+       three,
+       case_then2,
+       four,
+       case_close]).parse
+    expect(node.value(x: 3)).to eq(4)
+  end
 end

data/spec/token_scanner_spec.rb

@@ -28,7 +28,7 @@ describe Dentaku::TokenScanner do
   end
 
   it 'returns a list of all configured scanners' do
-    expect(described_class.scanners.length).to eq 12
+    expect(described_class.scanners.length).to eq 13
   end
 
   it 'allows customizing available scanners' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 2.0.5
+  version: 2.0.6
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-19 00:00:00.000000000 Z
+date: 2016-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -71,6 +71,12 @@ files:
 - lib/dentaku.rb
 - lib/dentaku/ast.rb
 - lib/dentaku/ast/arithmetic.rb
+- lib/dentaku/ast/case.rb
+- lib/dentaku/ast/case/case_conditional.rb
+- lib/dentaku/ast/case/case_else.rb
+- lib/dentaku/ast/case/case_switch_variable.rb
+- lib/dentaku/ast/case/case_then.rb
+- lib/dentaku/ast/case/case_when.rb
 - lib/dentaku/ast/combinators.rb
 - lib/dentaku/ast/comparators.rb
 - lib/dentaku/ast/function.rb
@@ -105,6 +111,7 @@ files:
 - lib/dentaku/version.rb
 - spec/ast/addition_spec.rb
 - spec/ast/and_spec.rb
+- spec/ast/case_spec.rb
 - spec/ast/division_spec.rb
 - spec/ast/function_spec.rb
 - spec/ast/node_spec.rb
@@ -148,6 +155,7 @@ summary: A formula language parser and evaluator
 test_files:
 - spec/ast/addition_spec.rb
 - spec/ast/and_spec.rb
+- spec/ast/case_spec.rb
 - spec/ast/division_spec.rb
 - spec/ast/function_spec.rb
 - spec/ast/node_spec.rb
@@ -164,4 +172,3 @@ test_files:
 - spec/token_scanner_spec.rb
 - spec/token_spec.rb
 - spec/tokenizer_spec.rb
-has_rdoc: