template-ruby 0.4.0 → 0.5.0

data/lib/code/node/nothing.rb

@@ -1,7 +1,7 @@
 class Code
   class Node
     class Nothing < Node
-      def initialize
+      def initialize(parsed)
       end
 
       def evaluate(**args)

data/lib/code/node/number.rb

@@ -1,22 +1,24 @@
 class Code
   class Node
     class Number < Node
-      def initialize(number)
-        if number.key?(:base_2)
-          @number = ::Code::Node::Base2Number.new(number[:base_2])
-        elsif number.key?(:base_8)
-          @number = ::Code::Node::Base8Number.new(number[:base_8])
-        elsif number.key?(:base_10)
-          @number = ::Code::Node::Base10Number.new(number[:base_10])
-        elsif number.key?(:base_16)
-          @number = ::Code::Node::Base16Number.new(number[:base_16])
-        else
-          raise NotImplementedErorr.new(number.inspect)
+      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)
-        @number.evaluate(**args)
+        @statement.evaluate(**args)
       end
     end
   end

data/lib/code/node/operation.rb

@@ -1,32 +1,37 @@
 class Code
   class Node
     class Operation < Node
-      class Operation
+      class Operator < Node
         attr_reader :operator, :statement
 
-        def initialize(operation)
-          @operator = operation.fetch(:operator).to_s
-          @statement = ::Code::Node::Statement.new(operation.fetch(:statement))
+        def initialize(parsed)
+          @operator = parsed.delete(:operator)
+          @statement = Node::Statement.new(parsed.delete(:statement))
         end
       end
 
-      def initialize(operation)
-        @first = ::Code::Node::Statement.new(operation.fetch(:first))
-        @rest = operation.fetch(:rest)
-        @rest.map! do |operation|
-          ::Code::Node::Operation::Operation.new(operation)
-        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)
-        object = @first.evaluate(**args)
+        first = @first.evaluate(**args)
 
-        @rest.each do |operation|
-          other = operation.statement.evaluate(**args)
-          object = simple_call(object, operation.operator, other, **args)
-        end
+        @others.reduce(first) do |left, right|
+          statement = right.statement.evaluate(**args)
 
-        object
+          left.call(
+            operator: right.operator,
+            arguments: [::Code::Object::Argument.new(statement)],
+            **args
+          )
+        end
       end
     end
   end

data/lib/code/node/power.rb

@@ -1,15 +1,19 @@
 class Code
   class Node
     class Power < Node
-      def initialize(power)
-        @left = ::Code::Node::Statement.new(power.fetch(:left))
-        @right = ::Code::Node::Statement.new(power.fetch(:right))
+      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)
-        right = @right.evaluate(**args)
-        left = @left.evaluate(**args)
-        simple_call(left, :**, right, **args)
+        @left.evaluate(**args).call(
+          operator: @operator,
+          arguments: [::Code::Object::Argument.new(@right.evaluate(**args))],
+          **args
+        )
       end
     end
   end

data/lib/code/node/rescue.rb

@@ -1,9 +1,10 @@
 class Code
   class Node
     class Rescue < Node
-      def initialize(power)
-        @left = ::Code::Node::Statement.new(power.fetch(:left))
-        @right = ::Code::Node::Statement.new(power.fetch(:right))
+      def initialize(parsed)
+        @left = Node::Statement.new(parsed.delete(:left))
+        @right = Node::Statement.new(parsed.delete(:right))
+        super(parsed)
       end
 
       def evaluate(**args)

data/lib/code/node/splat.rb

@@ -0,0 +1,15 @@
+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,80 +1,58 @@
 class Code
   class Node
     class Statement < Node
-      attr_reader :statement
-
-      def initialize(statement)
-        if statement.key?(:nothing)
-          @statement = ::Code::Node::Nothing.new
-        elsif statement.key?(:boolean)
-          @statement = ::Code::Node::Boolean.new(statement[:boolean])
-        elsif statement.key?(:number)
-          @statement = ::Code::Node::Number.new(statement[:number])
-        elsif statement.key?(:string)
-          @statement = ::Code::Node::String.new(statement[:string])
-        elsif statement.key?(:call)
-          @statement = ::Code::Node::Call.new(statement[:call])
-        elsif statement.key?(:name)
-          @statement = ::Code::Node::Name.new(statement[:name])
-        elsif statement.key?(:list)
-          @statement = ::Code::Node::List.new(statement[:list])
-        elsif statement.key?(:dictionnary)
-          @statement = ::Code::Node::Dictionnary.new(statement[:dictionnary])
-        elsif statement.key?(:negation)
-          @statement = ::Code::Node::Negation.new(statement[:negation])
-        elsif statement.key?(:power)
-          @statement = ::Code::Node::Power.new(statement[:power])
-        elsif statement.key?(:unary_minus)
-          @statement = ::Code::Node::UnaryMinus.new(statement[:unary_minus])
-        elsif statement.key?(:multiplication)
-          @statement = ::Code::Node::Operation.new(statement[:multiplication])
-        elsif statement.key?(:addition)
-          @statement = ::Code::Node::Operation.new(statement[:addition])
-        elsif statement.key?(:shift)
-          @statement = ::Code::Node::Operation.new(statement[:shift])
-        elsif statement.key?(:bitwise_and)
-          @statement = ::Code::Node::Operation.new(statement[:bitwise_and])
-        elsif statement.key?(:bitwise_or)
-          @statement = ::Code::Node::Operation.new(statement[:bitwise_or])
-        elsif statement.key?(:greater_than)
-          @statement = ::Code::Node::Operation.new(statement[:greater_than])
-        elsif statement.key?(:equality)
-          @statement = ::Code::Node::Operation.new(statement[:equality])
-        elsif statement.key?(:and_operator)
-          @statement = ::Code::Node::Operation.new(statement[:and_operator])
-        elsif statement.key?(:or_operator)
-          @statement = ::Code::Node::Operation.new(statement[:or_operator])
-        elsif statement.key?(:range)
-          @statement = ::Code::Node::Range.new(statement[:range])
-        elsif statement.key?(:ternary)
-          @statement = ::Code::Node::Ternary.new(statement[:ternary])
-        elsif statement.key?(:rescue)
-          @statement = ::Code::Node::Rescue.new(statement[:rescue])
-        elsif statement.key?(:equal)
-          @statement = ::Code::Node::Equal.new(statement[:equal])
-        elsif statement.key?(:defined)
-          @statement = ::Code::Node::Defined.new(statement[:defined])
-        elsif statement.key?(:not_keyword)
-          @statement = ::Code::Node::NotKeyword.new(statement[:not_keyword])
-        elsif statement.key?(:or_keyword)
-          @statement = ::Code::Node::OrKeyword.new(statement[:or_keyword])
-        elsif statement.key?(:if_modifier)
-          @statement = ::Code::Node::IfModifier.new(statement[:if_modifier])
-        elsif statement.key?(:if)
-          @statement = ::Code::Node::If.new(statement[:if])
-        elsif statement.key?(:while)
-          @statement = ::Code::Node::While.new(statement[:while])
-        elsif statement.key?(:group)
-          @statement = ::Code::Node::Group.new(statement[:group])
-        elsif statement.key?(:function)
-          @statement = ::Code::Node::Function.new(statement[:function])
-        else
-          raise NotImplementedError.new(statement.inspect)
+      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.merge(object: ::Code::Object::Global.new))
+        @statement.evaluate(**args)
       end
     end
   end

data/lib/code/node/string.rb

@@ -1,26 +1,52 @@
 class Code
   class Node
     class String < Node
-      def initialize(string)
-        if string.to_s.blank?
-          @string = []
-        elsif string.is_a?(Array)
-          @string =
-            string.map do |component|
-              ::Code::Node::StringComponent.new(component)
-            end
-        else
-          @string = [::Code::Node::StringCharacters.new(string)]
+      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)
-        string =
-          @string
-            .map { |component| component.evaluate(**args) }
-            .map(&:to_s)
-            .join
-        ::Code::Object::String.new(string)
+        ::Code::Object::String.new(
+          @parts.map { |part| part.evaluate(**args) }.map(&:to_s).join
+        )
       end
     end
   end

data/lib/code/node/ternary.rb

@@ -1,19 +1,17 @@
 class Code
   class Node
     class Ternary < Node
-      def initialize(ternary)
-        @left = ::Code::Node::Statement.new(ternary.fetch(:left))
-        @middle = ::Code::Node::Statement.new(ternary.fetch(:middle))
-
-        if ternary.key?(:right)
-          @right = ::Code::Node::Statement.new(ternary.fetch(:right))
+      def initialize(parsed)
+        @left = Node::Statement.new(parsed.delete(:left))
+        @middle = Node::Statement.new(parsed.delete(:middle))
+        if parsed.key?(:right)
+          @right = Node::Statement.new(parsed.delete(:right))
         end
+        super(parsed)
       end
 
       def evaluate(**args)
-        left = @left.evaluate(**args)
-
-        if left.truthy?
+        if @left.evaluate(**args).truthy?
           @middle.evaluate(**args)
         elsif @right
           @right.evaluate(**args)

data/lib/code/node/unary_minus.rb

@@ -1,21 +1,14 @@
 class Code
   class Node
     class UnaryMinus < Node
-      def initialize(unary_minus)
-        @statement = ::Code::Node::Statement.new(unary_minus)
+      def initialize(parsed)
+        @operator = parsed.delete(:operator)
+        @right = Node::Statement.new(parsed.delete(:right))
+        super(parsed)
       end
 
       def evaluate(**args)
-        object = @statement.evaluate(**args)
-
-        case object
-        when ::Code::Object::Integer
-          ::Code::Object::Integer.new(-object.raw)
-        when ::Code::Object::Decimal
-          ::Code::Object::Decimal.new(-object.raw)
-        else
-          ::Code::Object::Nothing.new
-        end
+        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
       end
     end
   end

data/lib/code/node/while.rb

@@ -1,42 +1,35 @@
 class Code
   class Node
     class While < Node
-      WHILE_KEYWORD = :while
-      UNTIL_KEYWORD = :until
-
-      def initialize(while_parsed)
-        @operator = while_parsed.fetch(:operator)
-        @statement = ::Code::Node::Statement.new(while_parsed.fetch(:statement))
-        @body = ::Code::Node::Code.new(while_parsed.fetch(:body))
+      WHILE_KEYWORD = "while"
+      UNTIL_KEYWORD = "until"
+
+      def initialize(parsed)
+        @operator = parsed.delete(:operator)
+        @statement = Node::Statement.new(parsed.delete(:statement))
+        @body = Node::Code.new(parsed.delete(:body))
+        super(parsed)
       end
 
       def evaluate(**args)
-        if operator == WHILE_KEYWORD
-          object = ::Code::Object::Nothing.new
+        if @operator == WHILE_KEYWORD
+          last = ::Code::Object::Nothing.new
 
           while @statement.evaluate(**args).truthy?
-            object = @body.evaluate(**args)
+            last = @body.evaluate(**args)
           end
 
-          object
-        elsif operator == UNTIL_KEYWORD
-          object = ::Code::Object::Nothing.new
+          last
+        elsif @operator == UNTIL_KEYWORD
+          last = ::Code::Object::Nothing.new
 
-          until @statement.evaluate(**args).truthy?
-            object = @body.evaluate(**args)
-          end
+          last = @body.evaluate(**args) while @statement.evaluate(**args).falsy?
 
-          object
+          last
         else
-          raise NotImplementedError.new(operator.inspect)
+          raise NotImplementedError.new(@operator)
         end
       end
-
-      private
-
-      def operator
-        @operator.to_sym
-      end
     end
   end
 end

data/lib/code/node.rb

@@ -1,14 +1,13 @@
 class Code
   class Node
-    private
+    def initialize(parsed)
+      if parsed.any?
+        raise NotImplementedError.new(self.class.name + ": " + parsed.inspect)
+      end
+    end
 
-    def simple_call(object, operator = nil, value = nil, **args)
-      args = args.multi_fetch(*::Code::GLOBALS)
-      object.call(
-        operator: operator && ::Code::Object::String.new(operator.to_s),
-        arguments: [value && ::Code::Object::Argument.new(value)].compact,
-        **args
-      )
+    def evaluate(**args)
+      raise NotImplementedError.new(self.class.name + "#evaluate")
     end
   end
 end

data/lib/code/object/argument.rb

@@ -1,20 +1,11 @@
 class Code
   class Object
     class Argument
-      attr_reader :value, :name, :splat, :keyword_splat, :block
+      attr_reader :value, :name
 
-      def initialize(
-        value,
-        name: nil,
-        splat: false,
-        keyword_splat: false,
-        block: false
-      )
+      def initialize(value, name: nil)
         @value = value
         @name = name
-        @splat = !!splat
-        @keyword_splat = !!keyword_splat
-        @block = !!block
       end
 
       def regular?

data/lib/code/object/decimal.rb

@@ -18,52 +18,63 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
+        value = arguments.first&.value
 
         if operator == "%"
-          sig(arguments, ::Code::Object::Number)
-          modulo(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          modulo(value)
         elsif operator == "+"
-          sig(arguments, ::Code::Object)
-          plus(arguments.first.value)
+          if value
+            sig(arguments) { ::Code::Object }
+            plus(value)
+          else
+            sig(arguments)
+            self
+          end
         elsif operator == "-"
-          sig(arguments, ::Code::Object::Number)
-          minus(arguments.first.value)
+          if value
+            sig(arguments) { ::Code::Object::Number }
+            minus(value)
+          else
+            sig(arguments)
+            unary_minus
+          end
         elsif operator == "/"
-          sig(arguments, ::Code::Object::Number)
-          division(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          division(value)
         elsif operator == "*"
-          sig(arguments, ::Code::Object::Number)
-          multiplication(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          multiplication(value)
         elsif operator == "**"
-          sig(arguments, ::Code::Object::Number)
-          power(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          power(value)
         elsif operator == "<"
-          sig(arguments, ::Code::Object::Number)
-          inferior(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          inferior(value)
         elsif operator == "<="
-          sig(arguments, ::Code::Object::Number)
-          inferior_or_equal(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          inferior_or_equal(value)
         elsif operator == ">"
-          sig(arguments, ::Code::Object::Number)
-          superior(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          superior(value)
         elsif operator == ">="
-          sig(arguments, ::Code::Object::Number)
-          superior_or_equal(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          superior_or_equal(value)
         elsif operator == "<<"
-          sig(arguments, ::Code::Object::Number)
-          left_shift(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          left_shift(value)
         elsif operator == ">>"
-          sig(arguments, ::Code::Object::Number)
-          right_shift(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          right_shift(value)
         elsif operator == "&"
-          sig(arguments, ::Code::Object::Number)
-          bitwise_and(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_and(value)
         elsif operator == "|"
-          sig(arguments, ::Code::Object::Number)
-          bitwise_or(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_or(value)
         elsif operator == "^"
-          sig(arguments, ::Code::Object::Number)
-          bitwise_xor(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_xor(value)
         else
           super
         end
@@ -142,6 +153,10 @@ class Code
       def bitwise_xor(other)
         ::Code::Object::Integer.new(raw.to_i ^ other.raw.to_i)
       end
+
+      def unary_minus
+        ::Code::Object::Decimal.new(-raw)
+      end
     end
   end
 end

data/lib/code/object/dictionnary.rb

@@ -10,7 +10,8 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        globals = args.multi_fetch(*::Code::GLOBALS)
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
 
         if operator == "values"
           sig(arguments)
@@ -19,8 +20,8 @@ class Code
           sig(arguments)
           keys
         elsif operator == "each"
-          sig(arguments, ::Code::Object::Function)
-          each(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          each(value, **globals)
         elsif key?(operator)
           result = fetch(operator)
 
@@ -82,9 +83,9 @@ class Code
           argument.call(
             arguments: [
               ::Code::Object::Argument.new(key),
-              ::Code::Object::Argument.new(value),
+              ::Code::Object::Argument.new(value)
             ],
-            **globals,
+            **globals
           )
         end