template-ruby 0.5.5 → 0.6.0

data/lib/code/node/call.rb

@@ -1,47 +0,0 @@
-class Code
-  class Node
-    class Call < Node
-      class Block < Node
-        def initialize(parsed)
-          @parameters =
-            parsed
-              .delete(:parameters) { [] }
-              .map { |parameter| Node::FunctionParameter.new(parameter) }
-
-          @body = Node::Code.new(parsed.delete(:body))
-
-          super(parsed)
-        end
-
-        def evaluate(**args)
-          ::Code::Object::Argument.new(
-            ::Code::Object::Function.new(parameters: @parameters, body: @body)
-          )
-        end
-      end
-
-      def initialize(parsed)
-        @name = parsed.delete(:name)
-        @arguments =
-          parsed
-            .delete(:arguments) { [] }
-            .map { |argument| Node::CallArgument.new(argument) }
-
-        if parsed.key?(:block)
-          @block = Node::Call::Block.new(parsed.delete(:block))
-        end
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        arguments = @arguments.map { |argument| argument.evaluate(**args) }
-        arguments << @block.evaluate(**args) if @block
-
-        name = ::Code::Object::String.new(@name)
-
-        args.fetch(:object).call(operator: name, arguments: arguments, **args)
-      end
-    end
-  end
-end

data/lib/code/node/call_argument.rb

@@ -1,21 +0,0 @@
-class Code
-  class Node
-    class CallArgument < Node
-      def initialize(parsed)
-        @value = Node::Code.new(parsed.delete(:value))
-        @name = parsed.delete(:name)
-      end
-
-      def evaluate(**args)
-        if @name
-          ::Code::Object::Argument.new(
-            @value.evaluate(**args),
-            name: ::Code::Object::String.new(@name)
-          )
-        else
-          ::Code::Object::Argument.new(@value.evaluate(**args))
-        end
-      end
-    end
-  end
-end

data/lib/code/node/chained_call.rb

@@ -1,23 +0,0 @@
-class Code
-  class Node
-    class ChainedCall < Node
-      def initialize(parsed)
-        @first = Node::Statement.new(parsed.delete(:first))
-        @others =
-          parsed
-            .delete(:others)
-            .map { |operator| Node::Statement.new(operator) }
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        first = @first.evaluate(**args)
-
-        @others.reduce(first) do |acc, element|
-          element.evaluate(**args.merge(object: acc))
-        end
-      end
-    end
-  end
-end

data/lib/code/node/code.rb

@@ -1,20 +0,0 @@
-class Code
-  class Node
-    class Code < Node
-      def initialize(parsed)
-        @statements = parsed.map { |statement| Node::Statement.new(statement) }
-      end
-
-      def evaluate(**args)
-        last = ::Code::Object::Nothing.new
-
-        @statements.each do |statement|
-          last =
-            statement.evaluate(**args.merge(object: ::Code::Object::Global.new))
-        end
-
-        last
-      end
-    end
-  end
-end

data/lib/code/node/decimal.rb

@@ -1,26 +0,0 @@
-class Code
-  class Node
-    class Decimal < Node
-      def initialize(parsed)
-        @decimal = parsed.delete(:decimal)
-
-        if parsed.key?(:exponent)
-          @exponent = Node::Statement.new(parsed.delete(:exponent))
-        end
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        if @exponent
-          ::Code::Object::Decimal.new(
-            @decimal,
-            exponent: @exponent.evaluate(**args)
-          )
-        else
-          ::Code::Object::Decimal.new(@decimal)
-        end
-      end
-    end
-  end
-end

data/lib/code/node/dictionnary.rb

@@ -1,33 +0,0 @@
-class Code
-  class Node
-    class Dictionnary < Node
-      class KeyValue < Node
-        def initialize(parsed)
-          if parsed.key?(:statement)
-            @key = Node::Statement.new(parsed.delete(:statement))
-          elsif parsed.key?(:name)
-            @key = Node::String.new([{ text: parsed.delete(:name) }])
-          end
-
-          @value = Node::Code.new(parsed.delete(:value))
-        end
-
-        def evaluate(**args)
-          [@key.evaluate(**args), @value.evaluate(**args)]
-        end
-      end
-
-      def initialize(parsed)
-        parsed = [] if parsed == ""
-        @key_values =
-          parsed.map { |key_value| Node::Dictionnary::KeyValue.new(key_value) }
-      end
-
-      def evaluate(**args)
-        ::Code::Object::Dictionnary.new(
-          @key_values.map { |key_value| key_value.evaluate(**args) }.to_h
-        )
-      end
-    end
-  end
-end

data/lib/code/node/equal.rb

@@ -1,34 +0,0 @@
-class Code
-  class Node
-    class Equal < Node
-      def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @left = parsed.delete(:left)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        right = @right.evaluate(**args)
-        left = ::Code::Object::String.new(@left)
-        context = args.fetch(:context)
-
-        if @operator == ""
-          context[left] = right
-        else
-          if context[left].nil?
-            raise ::Code::Error::Undefined.new("#{left} is not defined")
-          end
-
-          context[left] = context.fetch(left).call(
-            operator: @operator,
-            arguments: [::Code::Object::Argument.new(right)],
-            **args
-          )
-        end
-
-        args[:context][left]
-      end
-    end
-  end
-end

data/lib/code/node/function.rb

@@ -1,20 +0,0 @@
-class Code
-  class Node
-    class Function < Node
-      def initialize(parsed)
-        @parameters =
-          parsed
-            .delete(:parameters) { [] }
-            .map { |parameter| Node::FunctionParameter.new(parameter) }
-
-        @body = Node::Code.new(parsed.delete(:body))
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        ::Code::Object::Function.new(parameters: @parameters, body: @body)
-      end
-    end
-  end
-end

data/lib/code/node/function_parameter.rb

@@ -1,31 +0,0 @@
-class Code
-  class Node
-    class FunctionParameter < Node
-      def initialize(parsed)
-        @name = parsed.delete(:name)
-        @keyword = !!parsed.delete(:keyword)
-        super(parsed)
-      end
-
-      def name
-        ::Code::Object::String.new(@name)
-      end
-
-      def regular?
-        !@keyword
-      end
-
-      def keyword?
-        !!@keyword
-      end
-
-      def regular_splat?
-        false
-      end
-
-      def keyword_splat?
-        false
-      end
-    end
-  end
-end

data/lib/code/node/if.rb

@@ -1,59 +0,0 @@
-class Code
-  class Node
-    class If < Node
-      IF_KEYWORD = "if"
-      UNLESS_KEYWORD = "unless"
-      ELSIF_KEYWORD = "elsif"
-      ELSE_KEYWORD = "else"
-
-      class Else < Node
-        attr_reader :operator, :statement, :body
-
-        def initialize(parsed)
-          @operator = parsed.delete(:operator)
-          @body = Node::Code.new(parsed.delete(:body))
-
-          if parsed.key?(:statement)
-            @statement = Node::Statement.new(parsed.delete(:statement))
-          end
-        end
-      end
-
-      def initialize(parsed)
-        @first_operator = parsed.delete(:first_operator)
-        @first_statement = Node::Statement.new(parsed.delete(:first_statement))
-        @first_body = Node::Code.new(parsed.delete(:first_body))
-        @elses =
-          parsed.delete(:elses) { [] }.map { |elses| Node::If::Else.new(elses) }
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        if @first_operator == IF_KEYWORD &&
-             @first_statement.evaluate(**args).truthy?
-          @first_body.evaluate(**args)
-        elsif @first_operator == UNLESS_KEYWORD &&
-              @first_statement.evaluate(**args).falsy?
-          @first_body.evaluate(**args)
-        else
-          @elses.each do |elses|
-            if elses.operator == ELSIF_KEYWORD &&
-                 elses.statement.evaluate(**args).truthy?
-              return elses.body.evaluate(**args)
-            elsif elses.operator == IF_KEYWORD &&
-                  elses.statement.evaluate(**args).truthy?
-              return elses.body.evaluate(**args)
-            elsif elses.operator == UNLESS_KEYWORD &&
-                  elses.statement.evaluate(**args).falsy?
-              return elses.body.evaluate(**args)
-            elsif elses.operator == ELSE_KEYWORD
-              return elses.body.evaluate(**args)
-            end
-          end
-
-          ::Code::Object::Nothing.new
-        end
-      end
-    end
-  end
-end

data/lib/code/node/if_modifier.rb

@@ -1,47 +0,0 @@
-class Code
-  class Node
-    class IfModifier < Node
-      IF_KEYWORD = "if"
-      UNLESS_KEYWORD = "unless"
-      WHILE_KEYWORD = "while"
-      UNTIL_KEYWORD = "until"
-
-      def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @left = Node::Statement.new(parsed.delete(:left))
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        if @operator == IF_KEYWORD
-          if @right.evaluate(**args).truthy?
-            @left.evaluate(**args)
-          else
-            ::Code::Object::Nothing.new
-          end
-        elsif @operator == UNLESS_KEYWORD
-          if @right.evaluate(**args).falsy?
-            @left.evaluate(**args)
-          else
-            ::Code::Object::Nothing.new
-          end
-        elsif @operator == WHILE_KEYWORD
-          last = ::Code::Object::Nothing.new
-
-          last = @left.evaluate(**args) while @right.evaluate(**args).truthy?
-
-          last
-        elsif @operator == UNTIL_KEYWORD
-          last = ::Code::Object::Nothing.new
-
-          last = @left.evaluate(**args) while @right.evaluate(**args).falsy?
-
-          last
-        else
-          raise NotImplementedError.new(@operator)
-        end
-      end
-    end
-  end
-end

data/lib/code/node/list.rb

@@ -1,16 +0,0 @@
-class Code
-  class Node
-    class List < Node
-      def initialize(parsed)
-        parsed = [] if parsed == ""
-        @elements = parsed.map { |element| Node::Code.new(element) }
-      end
-
-      def evaluate(**args)
-        ::Code::Object::List.new(
-          @elements.map { |element| element.evaluate(**args) }
-        )
-      end
-    end
-  end
-end

data/lib/code/node/negation.rb

@@ -1,15 +0,0 @@
-class Code
-  class Node
-    class Negation < Node
-      def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
-      end
-    end
-  end
-end

data/lib/code/node/not.rb

@@ -1,15 +0,0 @@
-class Code
-  class Node
-    class Not < Node
-      def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
-      end
-    end
-  end
-end

data/lib/code/node/nothing.rb

@@ -1,12 +0,0 @@
-class Code
-  class Node
-    class Nothing < Node
-      def initialize(parsed)
-      end
-
-      def evaluate(**args)
-        ::Code::Object::Nothing.new
-      end
-    end
-  end
-end

data/lib/code/node/number.rb

@@ -1,25 +0,0 @@
-class Code
-  class Node
-    class Number < Node
-      def initialize(parsed)
-        if parsed.key?(:decimal)
-          @statement = Node::Decimal.new(parsed.delete(:decimal))
-        elsif parsed.key?(:base_16)
-          @statement = Node::Base16.new(parsed.delete(:base_16))
-        elsif parsed.key?(:base_10)
-          @statement = Node::Base10.new(parsed.delete(:base_10))
-        elsif parsed.key?(:base_8)
-          @statement = Node::Base8.new(parsed.delete(:base_8))
-        elsif parsed.key?(:base_2)
-          @statement = Node::Base2.new(parsed.delete(:base_2))
-        end
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        @statement.evaluate(**args)
-      end
-    end
-  end
-end

data/lib/code/node/operation.rb

@@ -1,38 +0,0 @@
-class Code
-  class Node
-    class Operation < Node
-      class Operator < Node
-        attr_reader :operator, :statement
-
-        def initialize(parsed)
-          @operator = parsed.delete(:operator)
-          @statement = Node::Statement.new(parsed.delete(:statement))
-        end
-      end
-
-      def initialize(parsed)
-        @first = Node::Statement.new(parsed.delete(:first))
-        @others =
-          parsed
-            .delete(:others)
-            .map { |operator| Node::Operation::Operator.new(operator) }
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        first = @first.evaluate(**args)
-
-        @others.reduce(first) do |left, right|
-          statement = right.statement.evaluate(**args)
-
-          left.call(
-            operator: right.operator,
-            arguments: [::Code::Object::Argument.new(statement)],
-            **args
-          )
-        end
-      end
-    end
-  end
-end

data/lib/code/node/power.rb

@@ -1,20 +0,0 @@
-class Code
-  class Node
-    class Power < Node
-      def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @left = Node::Statement.new(parsed.delete(:left))
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        @left.evaluate(**args).call(
-          operator: @operator,
-          arguments: [::Code::Object::Argument.new(@right.evaluate(**args))],
-          **args
-        )
-      end
-    end
-  end
-end

data/lib/code/node/rescue.rb

@@ -1,17 +0,0 @@
-class Code
-  class Node
-    class Rescue < Node
-      def initialize(parsed)
-        @left = Node::Statement.new(parsed.delete(:left))
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        @left.evaluate(**args)
-      rescue ::Code::Error
-        @right.evaluate(**args)
-      end
-    end
-  end
-end

data/lib/code/node/splat.rb

@@ -1,15 +0,0 @@
-class Code
-  class Node
-    class Splat < Node
-      def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
-      end
-    end
-  end
-end

data/lib/code/node/statement.rb

@@ -1,59 +0,0 @@
-class Code
-  class Node
-    class Statement < Node
-      def initialize(parsed)
-        if parsed.key?(:nothing)
-          @statement = Node::Nothing.new(parsed.delete(:nothing))
-        elsif parsed.key?(:boolean)
-          @statement = Node::Boolean.new(parsed.delete(:boolean))
-        elsif parsed.key?(:group)
-          @statement = Node::Code.new(parsed.delete(:group))
-        elsif parsed.key?(:call)
-          @statement = Node::Call.new(parsed.delete(:call))
-        elsif parsed.key?(:number)
-          @statement = Node::Number.new(parsed.delete(:number))
-        elsif parsed.key?(:string)
-          @statement = Node::String.new(parsed.delete(:string))
-        elsif parsed.key?(:list)
-          @statement = Node::List.new(parsed.delete(:list))
-        elsif parsed.key?(:dictionnary)
-          @statement = Node::Dictionnary.new(parsed.delete(:dictionnary))
-        elsif parsed.key?(:chained_call)
-          @statement = Node::ChainedCall.new(parsed.delete(:chained_call))
-        elsif parsed.key?(:operation)
-          @statement = Node::Operation.new(parsed.delete(:operation))
-        elsif parsed.key?(:equal)
-          @statement = Node::Equal.new(parsed.delete(:equal))
-        elsif parsed.key?(:function)
-          @statement = Node::Function.new(parsed.delete(:function))
-        elsif parsed.key?(:negation)
-          @statement = Node::Negation.new(parsed.delete(:negation))
-        elsif parsed.key?(:power)
-          @statement = Node::Power.new(parsed.delete(:power))
-        elsif parsed.key?(:unary_minus)
-          @statement = Node::UnaryMinus.new(parsed.delete(:unary_minus))
-        elsif parsed.key?(:ternary)
-          @statement = Node::Ternary.new(parsed.delete(:ternary))
-        elsif parsed.key?(:rescue)
-          @statement = Node::Rescue.new(parsed.delete(:rescue))
-        elsif parsed.key?(:not)
-          @statement = Node::Not.new(parsed.delete(:not))
-        elsif parsed.key?(:if_modifier)
-          @statement = Node::IfModifier.new(parsed.delete(:if_modifier))
-        elsif parsed.key?(:if)
-          @statement = Node::If.new(parsed.delete(:if))
-        elsif parsed.key?(:while)
-          @statement = Node::While.new(parsed.delete(:while))
-        elsif parsed.key?(:splat)
-          @statement = Node::Splat.new(parsed.delete(:splat))
-        end
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        @statement.evaluate(**args)
-      end
-    end
-  end
-end

data/lib/code/node/string.rb

@@ -1,53 +0,0 @@
-class Code
-  class Node
-    class String < Node
-      class Part < Node
-        class Code < Node
-          def initialize(parsed)
-            @code = Node::Code.new(parsed)
-          end
-
-          def evaluate(**args)
-            @code.evaluate(**args)
-          end
-        end
-
-        class Text < Node
-          def initialize(parsed)
-            @text = parsed
-          end
-
-          def evaluate(**args)
-            ::Code::Object::String.new(@text)
-          end
-        end
-
-        def initialize(parsed)
-          if parsed.key?(:text)
-            @part = Node::String::Part::Text.new(parsed.delete(:text))
-          elsif parsed.key?(:code)
-            @part = Node::String::Part::Code.new(parsed.delete(:code))
-          end
-
-          super(parsed)
-        end
-
-        def evaluate(**args)
-          @part.evaluate(**args)
-        end
-      end
-
-      def initialize(parsed)
-        parsed = [] if parsed == ""
-
-        @parts = parsed.map { |part| Node::String::Part.new(part) }
-      end
-
-      def evaluate(**args)
-        ::Code::Object::String.new(
-          @parts.map { |part| part.evaluate(**args) }.map(&:to_s).join
-        )
-      end
-    end
-  end
-end