introhive_expression_language 0.6.8

data/lib/introhive_expression_language/iel/std_lib_assoc.rb

@@ -0,0 +1,84 @@
+module Platform
+  module IEL
+    class StdLibAssoc
+      class << self
+
+        def declare(defining_context)
+          StdLibList.declare(defining_context)
+          declare_assoc(defining_context)
+          declare_assoc_get(defining_context)
+          # declare_assoc_let(defining_context) # This needs to be reimplemented to ensure immutability of data structures
+        end
+
+        def assoc_get(associative_array, keys)
+          match = nil
+          # Still have to support single keys  - Strings and symbols. Convert them to a list so we can go through logic normally
+          keys = SexpParser::Node.list([keys]) unless keys.kind == :list
+
+          keys.value.each do |k|
+            match = associative_array.value.find do |kv_node|
+              kv_node.kind == :list && kv_node.value.size >= 2 && kv_node.value.first == k
+            end
+            break if match.nil?
+            associative_array = match.value[1]
+          end
+          if match
+            match.value[1]
+          else
+            SexpParser::Node.nil
+          end
+        end
+
+        # TODO this can be reused as a defining_context with tests
+        def assoc_contains(associative_array, key)
+          match = associative_array.value.find do |kv_node|
+            kv_node.kind == :list && kv_node.value.size >= 2 && kv_node.value.first == key
+          end
+          if match
+            SexpParser::Node.boolean(true)
+          else
+            SexpParser::Node.boolean(false)
+          end
+        end
+
+        private
+
+        def declare_assoc(defining_context)
+          Evaluator.eval_expr(%q{
+            [def assoc [va_pairs]
+                 /* Build an assoc from the arguments.
+                    Allows this expression to produce an assoc:
+                          [assoc [a 1] [b 2]] */
+              [
+                [list-prepend va_pairs 'assoc]
+              ]
+            ]
+          }, defining_context)
+        end
+
+        def declare_assoc_get(defining_context)
+          defining_context['assoc-get'] ||= Evaluator.wrap_native_function do |_calling_ctx, associative_array, key|
+            raise EvaluationError.new("associative_array argument to function 'assoc-get' must be of type list but it is #{associative_array.kind}", associative_array) unless associative_array.kind == :list
+            assoc_get(associative_array, key)
+          end
+        end
+
+        def declare_assoc_let(defining_context)
+          defining_context['assoc-let'] ||= Evaluator.wrap_native_function do |_calling_ctx, associative_array, key, value|
+            raise EvaluationError.new("associative_array argument to function 'assoc-let' must be of type list but it is #{associative_array.kind}", associative_array) unless associative_array.kind == :list
+            match = associative_array.value.find do |kv_node|
+              kv_node.kind == :list && kv_node.value.size >= 2 && kv_node.value.first == key
+            end
+            if match
+              match.value[1] = value
+            else
+              associative_array.value << SexpParser::Node.list([key, value], key.source, _calling_ctx)
+            end
+            value
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/introhive_expression_language/iel/std_lib_control.rb

@@ -0,0 +1,81 @@
+module Platform
+  module IEL
+    class StdLibControl
+
+      class << self
+
+        def declare(defining_context)
+          declare_def(defining_context)
+          declare_if(defining_context)
+          declare_quote(defining_context)
+          declare_block(defining_context)
+          declare_eval(defining_context)
+        end
+
+        private
+
+        def declare_def(defining_context)
+          defining_context['def'] ||= Evaluator.wrap_native_function do |calling_ctx, name__, arg_list__, body__|
+            raise EvaluationError.new("name argument to function 'def' must be of type symbol but it is #{name__.kind}", name__) unless name__.kind == :symbol
+            function_name = name__.value
+            arg_list = arg_list__.value.map do |n|
+              raise EvaluationError.new("function arg list member '#{n.inspect}' must be a symbol", n) unless n.kind == :symbol
+              n.value
+            end
+
+            raise EvaluationError.new("function body must be a list", body__) if body__.kind != :list
+
+            calling_ctx.enclosing_context[function_name] = SexpParser::Node.new(
+                :native_function,
+                body__.source,
+                {
+                    proc: Proc.new do |inner_ctx|
+                      Evaluator.eval_block(body__, inner_ctx)
+                    end,
+                    arg_list: arg_list
+                },
+                body__.context
+            )
+          end
+        end
+
+        def declare_if(defining_context)
+          defining_context['if'] ||= Evaluator.wrap_native_function do |calling_ctx, condition_node, true_body__, false_body__|
+            raise EvaluationError.new("Condition argument to function 'if' must be of type boolean but it is #{condition_node.kind}", condition_node) unless condition_node.kind == :boolean
+            if condition_node.value
+              Evaluator.eval_block(true_body__, calling_ctx)
+            else
+              Evaluator.eval_block(false_body__, calling_ctx)
+            end
+          end
+        end
+
+        def declare_quote(defining_context)
+          defining_context['quote'] ||= Evaluator.wrap_native_function do |_calling_ctx, arg__|
+            arg__
+          end
+        end
+
+        def declare_block(defining_context)
+          defining_context['block'] ||= Evaluator.wrap_native_function do |_calling_ctx, va_list_of_exprs__|
+            raise EvaluationError.new("list_of_exprs argument to function 'block' must be of type list but it is #{va_list_of_exprs__.kind}", va_list_of_exprs__) unless va_list_of_exprs__.kind == :list
+            rv = SexpParser::Node.nil(va_list_of_exprs__.source)
+            va_list_of_exprs__.value.each do |expr|
+              rv = Evaluator.eval_node(expr, _calling_ctx)
+            end
+            rv
+          end
+        end
+
+        def declare_eval(defining_context)
+          defining_context['eval'] ||= Evaluator.wrap_native_function do |calling_ctx, node__|
+            actual_code = calling_ctx[node__.value]
+            Evaluator.eval_node(actual_code, calling_ctx)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/introhive_expression_language/iel/std_lib_enum.rb

@@ -0,0 +1,30 @@
+module Platform
+  module IEL
+    class StdLibEnum
+
+      class << self
+
+        def declare(defining_context)
+          declare_map(defining_context)
+        end
+
+        private
+
+        def declare_map(defining_context)
+          defining_context['map'] ||= Evaluator.wrap_native_function do |calling_ctx, list, var_symbol__, code_block__|
+            raise EvaluationError.new("list argument to function 'map' must be of type list but it is #{list.kind}", list) unless list.kind == :list
+            raise EvaluationError.new("var_symbol argument to function 'map' must be of type symbol but it is #{var_symbol__.kind}", var_symbol__) unless var_symbol__.kind == :symbol
+            raise EvaluationError.new("code_block argument to function 'map' must be of type list but it is #{code_block__.kind}", code_block__) unless code_block__.kind == :list
+            SexpParser::Node.list(list.value.map do |item|
+              instance_context = EvaluationContext.new(calling_ctx)
+              instance_context[var_symbol__.value] = item
+              Evaluator.eval_block(code_block__, instance_context)
+            end, list.source)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/introhive_expression_language/iel/std_lib_existence.rb

@@ -0,0 +1,19 @@
+module Platform
+  module IEL
+    class StdLibExistence
+      class << self
+        def declare(defining_context)
+          declare_present(defining_context)
+        end
+
+        private
+
+        def declare_present(defining_context)
+          defining_context['present?'] ||= Evaluator.wrap_native_function do |calling_ctx, expr|
+            Platform::IEL::SexpParser::Node.boolean(expr.value.present?, expr.source, calling_ctx)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/introhive_expression_language/iel/std_lib_json.rb

@@ -0,0 +1,38 @@
+module Platform
+  module IEL
+    class StdLibJson
+      class << self
+
+        def declare(defining_context)
+          declare_json_build(defining_context)
+          declare_json_load(defining_context)
+        end
+
+        private
+
+        def declare_json_build(defining_context)
+          defining_context['json-build'] ||= Evaluator.wrap_native_function do |_calling_ctx, item|
+            struct = NodeUtil.to_native(item)
+            SexpParser::Node.string_literal(JSON.dump(struct), item.source, _calling_ctx)
+          end
+        end
+
+        def declare_json_load(defining_context)
+          defining_context['json-load'] ||= Evaluator.wrap_native_function do |_calling_ctx, json_string|
+            raise EvaluationError.new("json_string argument to function 'json-load' must be of type string_literal but it is #{json_string.kind}", json_string) unless json_string.kind == :string_literal
+            begin
+              doc = JSON.parse(json_string.value)
+              NodeUtil.from_native(doc)
+            rescue JSON::ParserError => e
+              _calling_ctx.root_context['json-last-error'] = SexpParser::Node.list([
+                                                                                       SexpParser::Node.string_literal(e.message.gsub(/\d{3}: /, ''))
+                                                                                   ])
+              SexpParser::Node.nil
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/introhive_expression_language/iel/std_lib_kind.rb

@@ -0,0 +1,88 @@
+module Platform
+  module IEL
+    class StdLibKind
+
+      class << self
+
+        def declare(defining_context)
+          KIND_TEST_FUNCTIONS.keys.each do |function_name|
+            send("declare_#{function_name}", defining_context)
+          end
+          declare_sym(defining_context)
+          declare_eq(defining_context)
+          declare_float(defining_context)
+          declare_int(defining_context)
+          declare_str(defining_context)
+        end
+
+        private
+
+        KIND_TEST_FUNCTIONS = {
+            'nil?' => :nil,
+            'list?' => :list,
+            'num?' => :numeric_literal,
+            'str?' => :string_literal,
+            'func?' => :native_function,
+            'nan?' => :nan,
+            'sym?' => :symbol
+        }.freeze
+        KIND_TEST_FUNCTIONS.each do |function_name, node_kind|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def declare_#{function_name}(defining_context)
+              defining_context['#{function_name}'] = Evaluator.wrap_native_function do |calling_ctx, expr|
+                Platform::IEL::SexpParser::Node.boolean(expr.kind == :#{node_kind}, expr.source)
+              end
+            end
+          RUBY
+        end
+
+        def declare_sym(defining_context)
+          defining_context['sym'] ||= Evaluator.wrap_native_function do |_calling_ctx, value|
+            raise EvaluationError.new("value argument to function 'sym' must be of type symbol or string but it is #{value.kind}", value) unless [:symbol, :string_literal].include?(value.kind)
+            Platform::IEL::SexpParser::Node.symbol(value.value, value.source)
+          end
+        end
+
+        def declare_eq(defining_context)
+          defining_context['='] ||= Evaluator.wrap_native_function do |_calling_ctx, left, right|
+            Platform::IEL::SexpParser::Node.boolean(left.value == right.value)
+          end
+        end
+
+        def declare_cast(defining_context, cast_name, allowed_kinds, cast_function)
+          defining_context[cast_name] ||= Evaluator.wrap_native_function do |_calling_ctx, operand|
+            raise EvaluationError.new("value argument to function '#{cast_name}' must be of type #{allowed_kinds.join(' or ')} but it is #{operand.kind}", operand) unless allowed_kinds.include? operand.kind
+            NodeUtil.from_native(operand.value.send(cast_function))
+          end
+        end
+
+        def declare_float(defining_context)
+          declare_cast(defining_context, 'float', [:numeric_literal, :string_literal, :nil], :to_f)
+        end
+
+        def declare_int(defining_context)
+          declare_cast(defining_context, 'int', [:numeric_literal, :string_literal, :nil], :to_i)
+        end
+
+        def declare_str(defining_context)
+          declare_cast(defining_context, 'str', [:symbol, :string_literal, :numeric_literal, :nan, :list, :nil, :boolean], :to_s)
+        end
+
+        # def declare_def_nn(defining_context)
+        #   Evaluator.eval_expr(%{
+        #                           [def def-nn [function_name] [
+        #                             [def [sym [join function_name "-nn"]]
+        #                                  [args function_name]
+        #                                  [
+        #                                     [function_name
+        #                                  ]
+        #                             ]
+        #                           ]]
+        #                       }, defining_context)
+        # end
+
+      end
+
+    end
+  end
+end

data/lib/introhive_expression_language/iel/std_lib_let.rb

@@ -0,0 +1,22 @@
+module Platform
+  module IEL
+    class StdLibLet
+      class << self
+
+        def declare(defining_context)
+          declare_let(defining_context)
+        end
+
+        private
+
+        def declare_let(defining_context)
+          defining_context['let'] ||= Evaluator.wrap_native_function do |_calling_ctx, symbol__, expr|
+            raise EvaluationError.new("symbol argument to function 'let' must be of type symbol but it is #{symbol__.kind}", symbol__) unless symbol__.kind == :symbol
+            _calling_ctx.enclosing_context[symbol__.value] = expr
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/introhive_expression_language/iel/std_lib_list.rb

@@ -0,0 +1,85 @@
+module Platform
+  module IEL
+    class StdLibList
+      class << self
+
+        def declare(defining_context)
+          declare_list_elem(defining_context)
+          declare_list_join(defining_context)
+          declare_list_append(defining_context)
+          declare_list_prepend(defining_context)
+          declare_list_len(defining_context)
+          declare_list_any(defining_context)
+        end
+
+        # Return an element from the list at its ordinal position. List indexes are zero based.
+        # If a negative index is provided then it specifies items from the end of the list.
+        #   e.g. 0 is the first item in the list
+        #       -1 is the last item in the list
+        #       -2 is the second-to-last item in the list
+        def list_elem(list_node, index_node)
+          raise EvaluationError.new("list argument to function 'list-elem' must be of type list but it is #{list_node.kind}", list_node) unless list_node.kind == :list
+          raise EvaluationError.new("index argument to function 'list-elem' must be of type numeric_literal but it is #{index_node.kind}", index_node) unless index_node.kind == :numeric_literal
+          index = index_node.value
+          if index >= list_node.value.size
+            SexpParser::Node.nil
+          elsif index < 0
+            index_from_end = list_node.value.size + index
+            if index_from_end < 0
+              SexpParser::Node.nil
+            else
+              list_node.value[index_from_end]
+            end
+          else
+            list_node.value[index]
+          end
+        end
+
+        private
+
+        def declare_list_elem(defining_context)
+          defining_context['list-elem'] ||= Evaluator.wrap_native_function do |_calling_ctx, list, index|
+            list_elem(list, index)
+          end
+        end
+
+        def declare_list_join(defining_context)
+          defining_context['list-join'] ||= Evaluator.wrap_native_function do |_calling_ctx, va_lists|
+            combined_list = []
+            va_lists.value.each_with_index do |arg, index|
+              raise EvaluationError.new("argument #{index+1} to function 'list-join' must be of type list but it is #{arg.kind}", arg) unless arg.kind == :list
+              combined_list.concat(arg.value)
+            end
+            SexpParser::Node.list(combined_list, va_lists.source)
+          end
+        end
+
+        def declare_list_append(defining_context)
+          defining_context['list-append'] ||= Evaluator.wrap_native_function do |_calling_ctx, list, item|
+            raise EvaluationError.new("argument list to function 'list-append' must be of type list but it is #{list.kind}", list) unless list.kind == :list
+            SexpParser::Node.list(list.value + [item], list.source)
+          end
+        end
+
+        def declare_list_prepend(defining_context)
+          defining_context['list-prepend'] ||= Evaluator.wrap_native_function do |_calling_ctx, list, item|
+            raise EvaluationError.new("argument list to function 'list-prepend' must be of type list but it is #{list.kind}", list) unless list.kind == :list
+            SexpParser::Node.list([item] + list.value, list.source)
+          end
+        end
+        def declare_list_len(defining_context)
+          defining_context['list-len'] ||= Evaluator.wrap_native_function do |_calling_ctx, list|
+            raise EvaluationError.new("argument list to function 'list-len' must be of type list but it is #{list.kind}", list) unless list.kind == :list
+            SexpParser::Node.numeric_literal(list.value.length)
+          end
+        end
+        def declare_list_any(defining_context)
+          defining_context['list-any?'] ||= Evaluator.wrap_native_function do |_calling_ctx, list, value|
+            raise EvaluationError.new("argument list to function 'list-any?' must be of type list but it is #{list.kind}", list) unless list.kind == :list
+            SexpParser::Node.boolean(list.value.include?(value))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/introhive_expression_language/iel/std_lib_logic.rb

@@ -0,0 +1,52 @@
+module Platform
+  module IEL
+    class StdLibLogic
+
+      class << self
+
+        def declare(defining_context)
+          declare_and(defining_context)
+          declare_or(defining_context)
+          declare_not(defining_context)
+        end
+
+        private
+
+        def declare_or(defining_context)
+          defining_context['or'] ||= Evaluator.wrap_native_function do |calling_ctx, va_conditions__|
+            raise EvaluationError.new("conditions argument to function 'or' must be of type list but it is #{va_conditions__.kind}", va_conditions__) unless va_conditions__.kind == :list
+            raise EvaluationError.new("function 'or' requires at least 2 arguments but #{va_conditions__.value.size} are provided", va_conditions__) if va_conditions__.value.size < 2
+
+            result = va_conditions__.value.each_with_index.any? do |condition, index|
+              condition = Evaluator.eval_node(condition, calling_ctx)
+              raise EvaluationError.new("Condition argument #{index} to function 'or' must be of type boolean but it is #{condition.kind}", condition) unless condition.kind == :boolean
+              condition.value
+            end
+            Platform::IEL::SexpParser::Node.boolean(result)
+          end
+        end
+
+        def declare_and(defining_context)
+          defining_context['and'] ||= Evaluator.wrap_native_function do |calling_ctx, va_conditions__|
+            raise EvaluationError.new("conditions argument to function 'and' must be of type list but it is #{va_conditions__.kind}", va_conditions__) unless va_conditions__.kind == :list
+            raise EvaluationError.new("function 'and' requires at least 2 arguments but #{va_conditions__.value.size} are provided", va_conditions__) if va_conditions__.value.size < 2
+
+            result = va_conditions__.value.each_with_index.all? do |condition, index|
+              condition = Evaluator.eval_node(condition, calling_ctx)
+              raise EvaluationError.new("Condition argument #{index} to function 'and' must be of type boolean but it is #{condition.kind}", condition) unless condition.kind == :boolean
+              condition.value
+            end
+            Platform::IEL::SexpParser::Node.boolean(result)
+          end
+        end
+
+        def declare_not(defining_context)
+          defining_context['not'] ||= Evaluator.wrap_native_function do |__calling_ctx, condition_node|
+            raise EvaluationError.new("Condition argument to function 'not' must be of type boolean but it is #{condition_node.kind}", condition_node) unless condition_node.kind == :boolean
+            Platform::IEL::SexpParser::Node.boolean(!condition_node.value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/introhive_expression_language/iel/std_lib_math.rb

@@ -0,0 +1,75 @@
+module Platform
+  module IEL
+    class StdLibMath
+
+      class << self
+
+        def declare(defining_context)
+          declare_add(defining_context)
+          declare_subtract(defining_context)
+          declare_multiply(defining_context)
+          declare_divide(defining_context)
+          declare_greater_than(defining_context)
+          declare_less_than(defining_context)
+          declare_greater_than_or_equal(defining_context)
+          declare_less_than_or_equal(defining_context)
+        end
+
+        private
+
+        def declare_add(defining_context)
+          defining_context['+'] ||= Evaluator.wrap_native_function do |_calling_ctx, operand1, operand2|
+            SexpParser::Node.numeric_literal(Evaluator.numeric_value_of(operand1) + Evaluator.numeric_value_of(operand2), operand1.source)
+          end
+        end
+
+        def declare_subtract(defining_context)
+          defining_context['-'] ||= Evaluator.wrap_native_function do |_calling_ctx, operand1, operand2|
+            SexpParser::Node.numeric_literal(Evaluator.numeric_value_of(operand1) - Evaluator.numeric_value_of(operand2), operand1.source)
+          end
+        end
+
+        def declare_multiply(defining_context)
+          defining_context['*'] ||= Evaluator.wrap_native_function do |_calling_ctx, operand1, operand2|
+            SexpParser::Node.numeric_literal(Evaluator.numeric_value_of(operand1) * Evaluator.numeric_value_of(operand2), operand1.source)
+          end
+        end
+
+        def declare_divide(defining_context)
+          defining_context['/'] ||= Evaluator.wrap_native_function do |_calling_ctx, operand1, operand2|
+            divisor = Evaluator.numeric_value_of(operand2)
+            if divisor == 0
+              SexpParser::Node.nan
+            else
+              SexpParser::Node.numeric_literal(Evaluator.numeric_value_of(operand1) / divisor, operand1.source)
+            end
+          end
+        end
+
+        def declare_greater_than(defining_context)
+          defining_context['>'] ||= Evaluator.wrap_native_function do |_calling_ctx, operand1, operand2|
+            SexpParser::Node.boolean(Evaluator.numeric_value_of(operand1) > Evaluator.numeric_value_of(operand2))
+          end
+        end
+
+        def declare_less_than(defining_context)
+          defining_context['<'] ||= Evaluator.wrap_native_function do |_calling_ctx, operand1, operand2|
+            SexpParser::Node.boolean(Evaluator.numeric_value_of(operand1) < Evaluator.numeric_value_of(operand2))
+          end
+        end
+
+        def declare_greater_than_or_equal(defining_context)
+          defining_context['>='] ||= Evaluator.wrap_native_function do |_calling_ctx, operand1, operand2|
+            SexpParser::Node.boolean(Evaluator.numeric_value_of(operand1) >= Evaluator.numeric_value_of(operand2))
+          end
+        end
+
+        def declare_less_than_or_equal(defining_context)
+          defining_context['<='] ||= Evaluator.wrap_native_function do |_calling_ctx, operand1, operand2|
+            SexpParser::Node.boolean(Evaluator.numeric_value_of(operand1) <= Evaluator.numeric_value_of(operand2))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/introhive_expression_language/iel/std_lib_number.rb

@@ -0,0 +1,28 @@
+require 'active_support/number_helper'
+module Platform
+  module IEL
+    class StdLibNumber
+      class << self
+
+        def declare(defining_context)
+          StdLibAssoc.declare(defining_context)
+          declare_money_humanize(defining_context)
+        end
+
+        private
+
+        def declare_money_humanize(defining_context)
+          defining_context['number-humanize'] ||= Evaluator.wrap_native_function do |_calling_ctx, number, units|
+            raise EvaluationError.new("Argument 'number' of function 'number-humanize' must be a numeric_literal", number) unless number.kind == :numeric_literal
+            raise EvaluationError.new("Argument 'units' of function 'number-humanize' must be a list or nil", units) unless units.kind == :list || units.kind == :nil
+
+            SexpParser::Node.string_literal(ActiveSupport::NumberHelper.number_to_human(number.value, units: Platform::IEL::NodeUtil.to_native(units)))
+          end
+        end
+      end
+    end
+  end
+end
+
+
+

data/lib/introhive_expression_language/iel/std_lib_regexp.rb

@@ -0,0 +1,30 @@
+module Platform
+  module IEL
+    class StdLibRegexp
+      class << self
+        def declare(defining_context)
+          declare_regexp_match?(defining_context)
+          declare_regexp_match(defining_context)
+        end
+
+        private
+
+        def declare_regexp_match?(defining_context)
+          defining_context['regexp-match?'] ||= Evaluator.wrap_native_function do |context, regexp, string|
+            raise EvaluationError.new("Argument 'regexp' of function 'regexp-match?' must be a string_literal but it is #{regexp.kind}", regexp) unless regexp.kind == :string_literal
+            raise EvaluationError.new("Argument 'string' of function 'regexp-match?' must be a string_literal but it is #{string.kind}", string) unless string.kind == :string_literal
+            SexpParser::Node.boolean(Regexp.new(regexp.value).match?(string.value), regexp.source, context)
+          end
+        end
+
+        def declare_regexp_match(defining_context)
+          defining_context['regexp-match'] ||= Evaluator.wrap_native_function do |context, regexp, string|
+            raise EvaluationError.new("Argument 'regexp' of function 'regexp-match' must be a string_literal but it is #{regexp.kind}", regexp) unless regexp.kind == :string_literal
+            raise EvaluationError.new("Argument 'string' of function 'regexp-match' must be a string_literal but it is #{string.kind}", string) unless string.kind == :string_literal
+            Platform::IEL::NodeUtil.from_native(Regexp.new(regexp.value).match(string.value).to_a)
+          end
+        end
+      end
+    end
+  end
+end