template-ruby 0.1.0 → 0.2.2

data/lib/code/node/rescue.rb

@@ -0,0 +1,16 @@
+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))
+      end
+
+      def evaluate(**args)
+        @left.evaluate(**args)
+      rescue ::Code::Error
+        @right.evaluate(**args)
+      end
+    end
+  end
+end

data/lib/code/node/statement.rb

@@ -1,6 +1,8 @@
 class Code
   class Node
-    class Statement
+    class Statement < Node
+      attr_reader :statement
+
       def initialize(statement)
         if statement.key?(:nothing)
           @statement = ::Code::Node::Nothing.new
@@ -18,13 +20,61 @@ class Code
           @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)
         end
       end
 
-      def evaluate(context)
-        @statement.evaluate(context)
+      def evaluate(**args)
+        @statement.evaluate(**args)
       end
     end
   end

data/lib/code/node/string.rb

@@ -1,11 +1,11 @@
 class Code
   class Node
-    class String
+    class String < Node
       def initialize(string)
         @string = string
       end
 
-      def evaluate(context)
+      def evaluate(**args)
         ::Code::Object::String.new(string.to_s)
       end
 

data/lib/code/node/ternary.rb

@@ -0,0 +1,26 @@
+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))
+        end
+      end
+
+      def evaluate(**args)
+        left = @left.evaluate(**args)
+
+        if left.truthy?
+          @middle.evaluate(**args)
+        elsif @right
+          @right.evaluate(**args)
+        else
+          ::Code::Object::Nothing.new
+        end
+      end
+    end
+  end
+end

data/lib/code/node/unary_minus.rb

@@ -0,0 +1,22 @@
+class Code
+  class Node
+    class UnaryMinus < Node
+      def initialize(unary_minus)
+        @statement = ::Code::Node::Statement.new(unary_minus)
+      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
+      end
+    end
+  end
+end

data/lib/code/node/while.rb

@@ -0,0 +1,42 @@
+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))
+      end
+
+      def evaluate(**args)
+        if operator == WHILE_KEYWORD
+          object = ::Code::Object::Nothing.new
+
+          while @statement.evaluate(**args).truthy?
+            object = @body.evaluate(**args)
+          end
+
+          object
+        elsif operator == UNTIL_KEYWORD
+          object = ::Code::Object::Nothing.new
+
+          until @statement.evaluate(**args).truthy?
+            object = @body.evaluate(**args)
+          end
+
+          object
+        else
+          raise NotImplementedError.new(operator.inspect)
+        end
+      end
+
+      private
+
+      def operator
+        @operator.to_sym
+      end
+    end
+  end
+end

data/lib/code/node.rb

@@ -1,4 +1,14 @@
 class Code
   class Node
+    private
+
+    def simple_call(object, operator = nil, value = nil, **args)
+      object.call(
+        operator: operator && ::Code::Object::String.new(operator.to_s),
+        arguments: [value && ::Code::Object::Argument.new(value)].compact,
+        context: args.fetch(:context),
+        io: args.fetch(:io),
+      )
+    end
   end
 end

data/lib/code/object/argument.rb

@@ -0,0 +1,41 @@
+class Code
+  class Object
+    class Argument < ::Code::Object
+      attr_reader :value, :name, :splat, :keyword_splat, :block
+
+      def initialize(
+        value,
+        name: nil,
+        splat: false,
+        keyword_splat: false,
+        block: false
+      )
+        @value = value
+        @name = name
+        @splat = !!splat
+        @keyword_splat = !!keyword_splat
+        @block = !!block
+      end
+
+      def regular?
+        !name
+      end
+
+      def keyword?
+        !regular?
+      end
+
+      def name_value
+        [name, value]
+      end
+
+      def to_s
+        "argument"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+  end
+end

data/lib/code/object/boolean.rb

@@ -7,21 +7,20 @@ class Code
         @raw = raw
       end
 
-      def to_s
-        raw.to_s
+      def truthy?
+        raw
       end
 
-      def inspect
-        to_s
+      def succ
+        ::Code::Object::Boolean.new(!raw)
       end
 
-      def ==(other)
-        raw == other.raw
+      def to_s
+        raw.to_s
       end
-      alias_method :eql?, :==
 
-      def hash
-        [self.class, raw].hash
+      def inspect
+        to_s
       end
     end
   end

data/lib/code/object/decimal.rb

@@ -1,13 +1,31 @@
-require "bigdecimal"
-
 class Code
   class Object
-    class Decimal < ::Code::Object
+    class Decimal < ::Code::Object::Number
       attr_reader :raw
 
       def initialize(decimal, exponent: nil)
         @raw = BigDecimal(decimal)
-        @raw = @raw * 10**exponent.raw if exponent
+
+        if exponent
+          if exponent.is_a?(::Code::Object::Number)
+            @raw = @raw * 10**exponent.raw
+          else
+            raise ::Code::Error::TypeError.new("exponent is not a number")
+          end
+        end
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+
+        if %w[% - + / * **].detect { |o| operator == o }
+          number_operation(operator.to_sym, arguments)
+        elsif %w[< <= > >=].detect { |o| operator == o }
+          comparaison(operator.to_sym, arguments)
+        else
+          super
+        end
       end
 
       def to_s
@@ -18,13 +36,18 @@ class Code
         to_s
       end
 
-      def ==(other)
-        raw == other.raw
+      private
+
+      def number_operation(operator, arguments)
+        sig(arguments, ::Code::Object::Number)
+        other = arguments.first.value
+        ::Code::Object::Decimal.new(raw.public_send(operator, other.raw))
       end
-      alias_method :eql?, :==
 
-      def hash
-        [self.class, raw].hash
+      def comparaison(operator, arguments)
+        sig(arguments, ::Code::Object::Number)
+        other = arguments.first.value
+        ::Code::Object::Boolean.new(raw.public_send(operator, other.raw))
       end
     end
   end

data/lib/code/object/dictionnary.rb

@@ -7,6 +7,35 @@ class Code
         @raw = raw
       end
 
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+
+        if operator == "values"
+          values(arguments)
+        elsif key?(operator)
+          fetch(operator)
+        else
+          super
+        end
+      end
+
+      def fetch(key)
+        raw.fetch(key)
+      end
+
+      def [](key)
+        raw[key]
+      end
+
+      def []=(key, value)
+        raw[key] = value
+      end
+
+      def key?(key)
+        raw.key?(key)
+      end
+
       def to_s
         "{#{raw.map { |key, value| "#{key.inspect} => #{value.inspect}" }.join(", ")}}"
       end
@@ -15,17 +44,11 @@ class Code
         to_s
       end
 
-      def fetch(key, default = ::Code::Object::Nothing.new)
-        raw.fetch(key, default)
-      end
-
-      def ==(other)
-        raw == other.raw
-      end
-      alias_method :eql?, :==
+      private
 
-      def hash
-        [self.class, raw].hash
+      def values(arguments)
+        sig(arguments)
+        ::Code::Object::List.new(raw.values)
       end
     end
   end

data/lib/code/object/function.rb

@@ -0,0 +1,64 @@
+class Code
+  class Object
+    class Function < ::Code::Object
+      def initialize(arguments:, body:)
+        @arguments = arguments
+        @body = body
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        context = args.fetch(:context)
+        io = args.fetch(:io)
+
+        if operator.nil?
+          call_function(args: arguments, context: context, io: io)
+        else
+          super
+        end
+      end
+
+      def to_s
+        ""
+      end
+
+      def inspect
+        "function"
+      end
+
+      private
+
+      attr_reader :arguments, :body
+
+      def call_function(args:, context:, io:)
+        new_context = context.dup
+        arguments.each.with_index do |argument, index|
+          if argument.regular?
+            if argument.splat?
+              new_context[argument.name] = ::Code::Object::List.new(
+                args.select(&:regular?).map(&:value),
+              )
+            elsif argument.keyword_splat?
+              new_context[argument.name] = ::Code::Object::Dictionnary.new(
+                args.select(&:keyword?).map(&:name_value).to_h,
+              )
+            else
+              arg = args[index]&.value
+              arg = argument.evaluate(context: new_context, io: io) if arg.nil?
+              new_context[argument.name] = arg
+            end
+          elsif argument.keyword?
+            arg = args.detect { |arg| arg.name == argument.name }&.value
+            arg = argument.evaluate(context: new_context, io: io) if arg.nil?
+            new_context[argument.name] = arg
+          else
+            raise NotImplementedError
+          end
+        end
+
+        body.evaluate(context: new_context, io: io)
+      end
+    end
+  end
+end

data/lib/code/object/integer.rb

@@ -1,11 +1,55 @@
 class Code
   class Object
-    class Integer < ::Code::Object
+    class Integer < ::Code::Object::Number
       attr_reader :raw
 
       def initialize(whole, exponent: nil)
         @raw = whole.to_i
-        @raw = @raw * 10**exponent.raw if exponent
+
+        if exponent
+          if exponent.is_a?(::Code::Object::Number)
+            @raw = @raw * 10**exponent.raw
+          else
+            raise ::Code::Error::TypeError.new("exponent is not a number")
+          end
+        end
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+
+        if operator == "even?"
+          even?(arguments)
+        elsif operator == "to_string"
+          code_to_s(arguments)
+        elsif operator == "*"
+          multiplication(arguments)
+        elsif operator == "/"
+          division(arguments)
+        elsif %w[% - + **].detect { |o| operator == o }
+          integer_or_decimal_operation(operator.to_sym, arguments)
+        elsif %w[> >= < <=].detect { |o| operator == o }
+          comparaison(operator.to_sym, arguments)
+        elsif %w[<< >> & | ^].detect { |o| operator == o }
+          integer_operation(operator.to_sym, arguments)
+        else
+          super
+        end
+      end
+
+      def +(other)
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw + other.raw)
+        elsif other.is_a?(::Code::Object::Decimal)
+          ::Code::Object::Decimal.new(raw + other.raw)
+        else
+          raise ::Code::Error::TypeError
+        end
+      end
+
+      def succ
+        ::Code::Object::Integer.new(raw + 1)
       end
 
       def to_s
@@ -16,13 +60,56 @@ class Code
         to_s
       end
 
-      def ==(other)
-        raw == other.raw
+      private
+
+      def even?(arguments)
+        sig(arguments)
+        ::Code::Object::Boolean.new(raw.even?)
+      end
+
+      def code_to_s(arguments)
+        sig(arguments)
+        ::Code::Object::String.new(raw.to_s)
+      end
+
+      def multiplication(arguments)
+        sig(arguments, [::Code::Object::Number, ::Code::Object::String])
+        other = arguments.first.value
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw * other.raw)
+        elsif other.is_a?(::Code::Object::Decimal)
+          ::Code::Object::Decimal.new(raw * other.raw)
+        else
+          ::Code::Object::String.new(other.raw * raw)
+        end
+      end
+
+      def division(arguments)
+        sig(arguments, ::Code::Object::Number)
+        other = arguments.first.value
+        ::Code::Object::Decimal.new(BigDecimal(raw) / other.raw)
+      end
+
+      def integer_or_decimal_operation(operator, arguments)
+        sig(arguments, ::Code::Object::Number)
+        other = arguments.first.value
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw.public_send(operator, other.raw))
+        else
+          ::Code::Object::Decimal.new(raw.public_send(operator, other.raw))
+        end
+      end
+
+      def integer_operation(operator, arguments)
+        sig(arguments, ::Code::Object::Integer)
+        other = arguments.first.value
+        ::Code::Object::Integer.new(raw.public_send(operator, other.raw))
       end
-      alias_method :eql?, :==
 
-      def hash
-        [self.class, raw].hash
+      def comparaison(operator, arguments)
+        sig(arguments, ::Code::Object::Number)
+        other = arguments.first.value
+        ::Code::Object::Boolean.new(raw.public_send(operator, other.raw))
       end
     end
   end