hayadentaku 3.5.7

data/spec/ast/division_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'dentaku/ast/arithmetic'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Division do
+  let(:five) { Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 5) }
+  let(:six)  { Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 6) }
+
+  let(:t)    { Dentaku::AST::Numeric.new Dentaku::Token.new(:logical, true) }
+
+  it 'allows access to its sub-trees' do
+    node = described_class.new(five, six)
+    expect(node.left).to eq(five)
+    expect(node.right).to eq(six)
+  end
+
+  it 'performs division' do
+    node = described_class.new(five, six)
+    expect(node.value.round(4)).to eq(0.8333)
+  end
+
+  it 'requires operands that respond to /' do
+    expect {
+      described_class.new(five, t)
+    }.to raise_error(Dentaku::NodeError, /requires operands/)
+
+    expression = Dentaku::AST::Multiplication.new(five, five)
+    group = Dentaku::AST::Grouping.new(expression)
+
+    expect {
+      described_class.new(group, five)
+    }.not_to raise_error
+  end
+
+  it 'allows operands that respond to division' do
+    # Sample struct that has a custom definition for division
+    Divisible = Struct.new(:value) do
+      def /(other)
+        case other
+        when Divisible
+          value + other.value
+        when Numeric
+          value + other
+        end
+      end
+
+      def zero?
+        value.zero?
+      end
+    end
+
+    operand_five = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Divisible.new(5))
+    operand_six = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Divisible.new(6))
+
+    expect {
+      described_class.new(operand_five, operand_six).value
+    }.not_to raise_error
+
+    expect {
+      described_class.new(operand_five, six).value
+    }.not_to raise_error
+  end
+end

data/spec/ast/filter_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/filter'
+require 'dentaku'
+
+describe Dentaku::AST::Filter do
+  let(:calculator) { Dentaku::Calculator.new }
+  it 'excludes unmatched values' do
+    result = Dentaku('SUM(FILTER(vals, val, val > 1))', vals: [1, 2, 3])
+    expect(result).to eq(5)
+  end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('FILTER(vals, val, val > 1)', vals: 1)
+    expect(result).to eq([])
+
+    result = Dentaku('FILTER(vals, val, val > 1)', vals: 2)
+    expect(result).to eq([2])
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('FILTER({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(
+      Dentaku::ParseError, 'FILTER() requires second argument to be an identifier'
+    )
+  end
+end

data/spec/ast/function_spec.rb

@@ -0,0 +1,69 @@
+require 'bigdecimal'
+require 'spec_helper'
+require 'dentaku/ast/function'
+require 'dentaku/exceptions'
+
+class Clazz; end
+
+describe Dentaku::AST::Function do
+  it 'maintains a function registry' do
+    expect(described_class).to respond_to(:get)
+  end
+
+  it 'registers a custom function' do
+    described_class.register("flarble", :string, -> { "flarble" })
+    expect { described_class.get("flarble") }.not_to raise_error
+    function = described_class.get("flarble").new
+    expect(function.value).to eq("flarble")
+  end
+
+  it 'does not throw an error when registering a function with a name that matches a currently defined constant' do
+    expect { described_class.register("clazz", :string, -> { "clazzified" }) }.not_to raise_error
+  end
+
+  describe "#arity" do
+    it "returns the correct arity for custom functions" do
+      zero = described_class.register("zero", :numeric, ->() { 0 })
+      expect(zero.arity).to eq(0)
+
+      one = described_class.register("one", :numeric, ->(x) { x * 2 })
+      expect(one.arity).to eq(1)
+
+      two = described_class.register("two", :numeric, ->(x, y) { x + y })
+      expect(two.arity).to eq(2)
+
+      many = described_class.register("many", :numeric, ->(*args) { args.max })
+      expect(many.arity).to be_nil
+    end
+  end
+
+  it 'casts a String to an Integer if possible' do
+    expect(described_class.numeric('3')).to eq(3)
+  end
+
+  it 'casts a String to a BigDecimal if possible and if Integer would loose information' do
+    expect(described_class.numeric('3.2')).to eq(3.2)
+  end
+
+  it 'casts a String to a BigDecimal with a negative number' do
+    expect(described_class.numeric('-3.2')).to eq(-3.2)
+  end
+
+  it 'casts a String to a BigDecimal without a leading zero' do
+    expect(described_class.numeric('-.2')).to eq(-0.2)
+  end
+
+  it 'raises an error if the value could not be cast to a Numeric' do
+    expect { described_class.numeric('flarble') }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric('-') }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric('') }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric(nil) }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric('7.') }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric(true) }.to raise_error Dentaku::ArgumentError
+  end
+
+  it "allows read access to arguments" do
+    fn = described_class.new(1, 2, 3)
+    expect(fn.args).to eq([1, 2, 3])
+  end
+end

data/spec/ast/intercept_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/intercept'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Intercept' do
+  it 'returns the correct intercept for given x and y arrays' do
+    x_values = [6, 13, 15, 10, 11, 10]
+    y_values = [-1, 8, 8,  13, 3, 15]
+    result = Dentaku('INTERCEPT(ys, xs)', xs: x_values, ys: y_values)
+    expect(result).to be_within(0.001).of(9.437)
+  end
+
+  context 'checking errors' do
+    it 'raises an error if arguments are not arrays' do
+      expect { Dentaku!("INTERCEPT(1, 2)") }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if the arrays are not of equal length' do
+      x_values = [1, 2, 3]
+      y_values = [2, 3, 5, 4]
+      expect { Dentaku!("INTERCEPT(y, x)", x: x_values, y: y_values) }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if any of the arrays is empty' do
+      x_values = []
+      y_values = [2, 3, 5, 4]
+      expect { Dentaku!("INTERCEPT(y, x)", x: x_values, y: y_values) }.to raise_error(Dentaku::ArgumentError)
+    end
+  end
+end

data/spec/ast/map_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/map'
+require 'dentaku'
+
+describe Dentaku::AST::Map do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'operates on each value in an array' do
+    result = Dentaku('SUM(MAP(vals, val, val + 1))', vals: [1, 2, 3])
+    expect(result).to eq(9)
+  end
+
+  it 'works with an empty array' do
+    result = Dentaku('MAP(vals, val, val + 1)', vals: [])
+    expect(result).to eq([])
+  end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('MAP(vals, val, val + 1)', vals: 1)
+    expect(result).to eq([2])
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('MAP({1, 2, 3}, "val", val + 1)') }.to raise_error(
+      Dentaku::ParseError,  'MAP() requires second argument to be an identifier'
+    )
+  end
+
+  it 'treats missing keys in hashes as NULL in permissive mode' do
+    expect(
+      calculator.evaluate('MAP(items, item, item.value)', items: [{value: 1}, {}])
+    ).to eq([1, nil])
+  end
+
+  it 'raises an error if accessing a missing key in a hash in strict mode' do
+    expect {
+      calculator.evaluate!('MAP(items, item, item.value)', items: [{value: 1}, {}])
+    }.to raise_error(Dentaku::UnboundVariableError)
+  end
+end

data/spec/ast/max_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/max'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Max' do
+  it 'returns the largest numeric value in an array of Numeric values' do
+    result = Dentaku('MAX(1, x, 1.8)', x: 2.3)
+    expect(result).to eq(2.3)
+  end
+
+  it 'returns the largest value even if a String is passed' do
+    result = Dentaku('MAX(1, x, 1.8)', x: '2.3')
+    expect(result).to eq(2.3)
+  end
+
+  it 'returns the largest value even if an Array is passed' do
+    result = Dentaku('MAX(1, x, 1.8)', x: [1.5, 2.3, 1.7])
+    expect(result).to eq(2.3)
+  end
+
+  it 'returns the largest value if only an Array is passed' do
+    result = Dentaku('MAX(x)', x: [1.5, 2.3, 1.7])
+    expect(result).to eq(2.3)
+  end
+
+  context 'checking errors' do
+    let(:calculator) { Dentaku::Calculator.new }
+
+    it 'does not raise an error if an empty array is passed' do
+      expect(calculator.evaluate!('MAX(x)', x: [])).to eq(nil)
+    end
+  end
+end

data/spec/ast/min_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/min'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Min' do
+  it 'returns the smallest numeric value in an array of Numeric values' do
+    result = Dentaku('MIN(1, x, 1.8)', x: 2.3)
+    expect(result).to eq(1)
+  end
+
+  it 'returns the smallest value even if a String is passed' do
+    result = Dentaku('MIN(1, x, 1.8)', x: '0.3')
+    expect(result).to eq(0.3)
+  end
+
+  it 'returns the smallest value even if an Array is passed' do
+    result = Dentaku('MIN(1, x, 1.8)', x: [1.5, 0.3, 1.7])
+    expect(result).to eq(0.3)
+  end
+
+  it 'returns the smallest value if only an Array is passed' do
+    result = Dentaku('MIN(x)', x: [1.5, 2.3, 1.7])
+    expect(result).to eq(1.5)
+  end
+
+  context 'checking errors' do
+    let(:calculator) { Dentaku::Calculator.new }
+
+    it 'does not raise an error if an empty array is passed' do
+      expect(calculator.evaluate!('MIN(x)', x: [])).to eq(nil)
+    end
+  end
+end

data/spec/ast/mul_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/mul'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Mul' do
+  it 'returns the product of an array of Numeric values' do
+    result = Dentaku('MUL(1, x, 1.8)', x: 2.3)
+    expect(result).to eq(4.14)
+  end
+
+  it 'returns the product of a single entry array of a Numeric value' do
+    result = Dentaku('MUL(x)', x: 2.3)
+    expect(result).to eq(2.3)
+  end
+
+  it 'coerces string inputs to numeric' do
+    result = Dentaku('mul(1, x, 1.8)', x: '2.3')
+    expect(result).to eq(4.14)
+  end
+
+  it 'returns the product even if an array is passed' do
+    result = Dentaku('mul(1, x, 2.3)', x: [4, 5])
+    expect(result).to eq(46)
+  end
+
+  it 'handles nested calls' do
+    result = Dentaku('mul(1, x, mul(4, 5))', x: '2.3')
+    expect(result).to eq(46)
+  end
+
+  context 'checking errors' do
+    let(:calculator) { Dentaku::Calculator.new }
+
+    it 'raises an error if no arguments are passed' do
+      expect { calculator.evaluate!('MUL()') }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'does not raise an error if an empty array is passed' do
+      result = calculator.evaluate!('MUL(x)', x: [])
+      expect(result).to eq(1)
+    end
+  end
+end

data/spec/ast/negation_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'dentaku/ast/arithmetic'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Negation do
+  let(:five) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 5) }
+  let(:t)    { Dentaku::AST::Logical.new Dentaku::Token.new(:logical, true) }
+  let(:x)    { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
+
+  it 'allows access to its sub-node' do
+    node = described_class.new(five)
+    expect(node.node).to eq(five)
+  end
+
+  it 'performs negation' do
+    node = described_class.new(five)
+    expect(node.value).to eq(-5)
+  end
+
+  it 'requires numeric operands' do
+    expect {
+      described_class.new(t)
+    }.to raise_error(Dentaku::NodeError, /requires numeric operands/)
+
+    expression = Dentaku::AST::Negation.new(five)
+    group = Dentaku::AST::Grouping.new(expression)
+
+    expect {
+      described_class.new(group)
+    }.not_to raise_error
+  end
+
+  it 'correctly parses string operands to numeric values' do
+    node = described_class.new(x)
+    expect(node.value('x' => '5')).to eq(-5)
+  end
+
+  it 'raises error if input string is not coercible to numeric' do
+    node = described_class.new(x)
+    expect { node.value('x' => 'invalid') }.to raise_error(Dentaku::ArgumentError)
+  end
+
+  it 'raises error if given a non-numeric argument' do
+    node = described_class.new(x)
+    expect { node.value('x' => true) }.to raise_error(Dentaku::ArgumentError)
+  end
+end

data/spec/ast/node_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'dentaku/ast/node'
+require 'dentaku/tokenizer'
+require 'dentaku/parser'
+
+describe Dentaku::AST::Node do
+  it 'returns list of dependencies' do
+    node = make_node('x + 5')
+    expect(node.dependencies).to eq(['x'])
+
+    node = make_node('5 < x')
+    expect(node.dependencies).to eq(['x'])
+
+    node = make_node('5 < 7')
+    expect(node.dependencies).to eq([])
+
+    node = make_node('(y * 7)')
+    expect(node.dependencies).to eq(['y'])
+
+    node = make_node('if(x > 5, y, z)')
+    expect(node.dependencies).to eq(['x', 'y', 'z'])
+
+    node = make_node('if(x > 5, y, z)')
+    expect(node.dependencies('x' => 7)).to eq(['y'])
+
+    node = make_node('if(x > 5, y, z)')
+    expect(node.dependencies('x' => 2)).to eq(['z'])
+
+    node = make_node('')
+    expect(node.dependencies).to eq([])
+  end
+
+  it 'returns unique list of dependencies' do
+    node = make_node('x + x')
+    expect(node.dependencies).to eq(['x'])
+  end
+
+  private
+
+  def make_node(expression)
+    Dentaku::Parser.new(Dentaku::Tokenizer.new.tokenize(expression)).parse
+  end
+end

data/spec/ast/numeric_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'dentaku/ast/numeric'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Numeric do
+  subject { described_class.new(Dentaku::Token.new(:numeric, 5)) }
+
+  it 'has numeric type' do
+    expect(subject.type).to eq(:numeric)
+  end
+
+  it 'has no dependencies' do
+    expect(subject.dependencies).to be_empty
+  end
+end

data/spec/ast/or_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/ast/functions/or'
+
+describe 'Dentaku::AST::Or' do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'returns false if all of the arguments are false' do
+    result = Dentaku('OR(1 = "2", 0 = 1)')
+    expect(result).to eq(false)
+  end
+
+  it 'supports nested expressions' do
+    result = Dentaku('OR(y = 1, x = 1)', x: 1, y: 2)
+    expect(result).to eq(true)
+  end
+
+  it 'returns true if any of the arguments is true' do
+    result = Dentaku('OR(1 = "1", "2" = "2", true = false, false)')
+    expect(result).to eq(true)
+  end
+
+  it 'returns true if any nested OR function returns true' do
+    result = Dentaku('OR(OR(1 = 0), OR(true = false, OR(true)))')
+    expect(result).to eq(true)
+  end
+
+  it 'raises an error if no arguments are passed' do
+    expect { calculator.evaluate!('OR()') }.to raise_error(Dentaku::ArgumentError)
+  end
+
+  it 'raises an error if a non logical argument is passed' do
+    expect { calculator.evaluate!('OR("r")') }.to raise_error(Dentaku::ArgumentError)
+  end
+end

data/spec/ast/pluck_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/pluck'
+require 'dentaku'
+
+describe Dentaku::AST::Pluck do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'operates on each value in an array' do
+    result = Dentaku('PLUCK(users, age)', users: [
+      {name: "Bob",  age: 44},
+      {name: "Jane", age: 27}
+    ])
+    expect(result).to eq([44, 27])
+  end
+
+  it 'allows specifying a default for missing values' do
+    result = Dentaku!('PLUCK(users, age, -1)', users: [
+      {name: "Bob"},
+      {name: "Jane", age: 27}
+    ])
+    expect(result).to eq([-1, 27])
+  end
+
+  it 'returns nil if pluck key is missing from a hash' do
+    result = Dentaku!('PLUCK(users, age)', users: [
+      {name: "Bob"},
+      {name: "Jane", age: 27}
+    ])
+    expect(result).to eq([nil, 27])
+  end
+
+  it 'works with an empty array' do
+    result = Dentaku('PLUCK(users, age)', users: [])
+    expect(result).to eq([])
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect do Dentaku.evaluate!('PLUCK(users, "age")', users: [
+      {name: "Bob",  age: 44},
+      {name: "Jane", age: 27}
+    ]) end.to raise_error(Dentaku::ParseError, 'PLUCK() requires second argument to be an identifier')
+  end
+
+  it 'raises argument error if a non array of hashes is passed as collection' do
+    expect { calculator.evaluate!('PLUCK({1, 2, 3}, age)') }.to raise_error(
+      Dentaku::ArgumentError, 'PLUCK() requires first argument to be an array of hashes'
+    )
+  end
+end

data/spec/ast/reduce_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/reduce'
+require 'dentaku'
+
+describe Dentaku::AST::Reduce do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'performs REDUCE operation with initial value' do
+    result = Dentaku('REDUCE(vals, memo, val, CONCAT(memo, val), "hello")', vals: ["wo", "rl", "d"])
+    expect(result).to eq("helloworld")
+  end
+
+  it 'performs REDUCE operation without initial value' do
+    result = Dentaku('REDUCE(vals, memo, val, CONCAT(memo, val))', vals: ["wo", "rl", "d"])
+    expect(result).to eq("world")
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('REDUCE({1, 2, 3}, memo, "val", memo + val)') }.to raise_error(Dentaku::ParseError)
+    expect { calculator.evaluate!('REDUCE({1, 2, 3}, "memo", val, memo + val)') }.to raise_error(Dentaku::ParseError)
+  end
+end

data/spec/ast/round_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/round'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Round' do
+  it 'returns the rounded down value' do
+    result = Dentaku('ROUND(1.8)')
+    expect(result).to eq(2)
+  end
+
+  it 'returns the rounded down value to the given precision' do
+    result = Dentaku('ROUND(x, y)', x: 1.8453, y: 3)
+    expect(result).to eq(1.845)
+  end
+
+  it 'returns the rounded down value to the given precision, also with strings' do
+    result = Dentaku('ROUND(x, y)', x: '1.8453', y: '3')
+    expect(result).to eq(1.845)
+  end
+
+  it 'returns the rounded down value to the given precision, also with nil' do
+    result = Dentaku('ROUND(x, y)', x: '1.8453', y: nil)
+    expect(result).to eq(2)
+  end
+
+  context 'checking errors' do
+    it 'raises an error if first argument is not numeric' do
+      expect { Dentaku!("ROUND(2020-1-1, 0)") }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if places is not numeric' do
+      expect { Dentaku!("ROUND(1.8, 2020-1-1)") }.to raise_error(Dentaku::ArgumentError)
+    end
+  end
+end

data/spec/ast/rounddown_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/rounddown'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Round' do
+  it 'returns the rounded value' do
+    result = Dentaku('ROUNDDOWN(1.8)')
+    expect(result).to eq(1)
+  end
+
+  it 'returns the rounded value to the given precision' do
+    result = Dentaku('ROUNDDOWN(x, y)', x: 1.8453, y: 3)
+    expect(result).to eq(1.845)
+  end
+
+  it 'returns the rounded value to the given precision, also with strings' do
+    result = Dentaku('ROUNDDOWN(x, y)', x: '1.8453', y: '3')
+    expect(result).to eq(1.845)
+  end
+
+  it 'returns the rounded value to the given precision, also with nil' do
+    result = Dentaku('ROUNDDOWN(x, y)', x: '1.8453', y: nil)
+    expect(result).to eq(1)
+  end
+
+  context 'checking errors' do
+    it 'raises an error if first argument is not numeric' do
+      expect { Dentaku!("ROUND(2020-1-1, 0)") }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if places is not numeric' do
+      expect { Dentaku!("ROUND(1.8, 2020-1-1)") }.to raise_error(Dentaku::ArgumentError)
+    end
+  end
+end

data/spec/ast/roundup_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/roundup'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Round' do
+  it 'returns the rounded value' do
+    result = Dentaku('ROUNDUP(1.8)')
+    expect(result).to eq(2)
+  end
+
+  it 'returns the rounded value to the given precision' do
+    result = Dentaku('ROUNDUP(x, y)', x: 1.8453, y: 3)
+    expect(result).to eq(1.846)
+  end
+
+  it 'returns the rounded value to the given precision, also with strings' do
+    result = Dentaku('ROUNDUP(x, y)', x: '1.8453', y: '3')
+    expect(result).to eq(1.846)
+  end
+
+  it 'returns the rounded value to the given precision, also with nil' do
+    result = Dentaku('ROUNDUP(x, y)', x: '1.8453', y: nil)
+    expect(result).to eq(2)
+  end
+
+  context 'checking errors' do
+    it 'raises an error if first argument is not numeric' do
+      expect { Dentaku!("ROUND(2020-1-1, 0)") }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if places is not numeric' do
+      expect { Dentaku!("ROUND(1.8, 2020-1-1)") }.to raise_error(Dentaku::ArgumentError)
+    end
+  end
+end