language-ruby 0.5.0

data/lib/code/node/rescue.rb

@@ -0,0 +1,17 @@
+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

@@ -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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,53 @@
+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

data/lib/code/node/ternary.rb

@@ -0,0 +1,24 @@
+class Code
+  class Node
+    class Ternary < Node
+      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)
+        if @left.evaluate(**args).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,15 @@
+class Code
+  class Node
+    class UnaryMinus < 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/while.rb

@@ -0,0 +1,35 @@
+class Code
+  class Node
+    class While < Node
+      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
+          last = ::Code::Object::Nothing.new
+
+          while @statement.evaluate(**args).truthy?
+            last = @body.evaluate(**args)
+          end
+
+          last
+        elsif @operator == UNTIL_KEYWORD
+          last = ::Code::Object::Nothing.new
+
+          last = @body.evaluate(**args) while @statement.evaluate(**args).falsy?
+
+          last
+        else
+          raise NotImplementedError.new(@operator)
+        end
+      end
+    end
+  end
+end

data/lib/code/node.rb

@@ -0,0 +1,13 @@
+class Code
+  class Node
+    def initialize(parsed)
+      if parsed.any?
+        raise NotImplementedError.new(self.class.name + ": " + parsed.inspect)
+      end
+    end
+
+    def evaluate(**args)
+      raise NotImplementedError.new(self.class.name + "#evaluate")
+    end
+  end
+end

data/lib/code/object/argument.rb

@@ -0,0 +1,32 @@
+class Code
+  class Object
+    class Argument
+      attr_reader :value, :name
+
+      def initialize(value, name: nil)
+        @value = value
+        @name = name
+      end
+
+      def regular?
+        !name
+      end
+
+      def keyword?
+        !regular?
+      end
+
+      def name_value
+        [name, value]
+      end
+
+      def to_s
+        "<Argument #{value.inspect}>"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+  end
+end

data/lib/code/object/boolean.rb

@@ -0,0 +1,27 @@
+class Code
+  class Object
+    class Boolean < ::Code::Object
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def truthy?
+        raw
+      end
+
+      def succ
+        ::Code::Object::Boolean.new(!raw)
+      end
+
+      def to_s
+        raw.to_s
+      end
+
+      def inspect
+        to_s
+      end
+    end
+  end
+end

data/lib/code/object/decimal.rb

@@ -0,0 +1,162 @@
+class Code
+  class Object
+    class Decimal < ::Code::Object::Number
+      attr_reader :raw
+
+      def initialize(decimal, exponent: nil)
+        @raw = BigDecimal(decimal)
+
+        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, [])
+        value = arguments.first&.value
+
+        if operator == "%"
+          sig(arguments) { ::Code::Object::Number }
+          modulo(value)
+        elsif operator == "+"
+          if value
+            sig(arguments) { ::Code::Object }
+            plus(value)
+          else
+            sig(arguments)
+            self
+          end
+        elsif operator == "-"
+          if value
+            sig(arguments) { ::Code::Object::Number }
+            minus(value)
+          else
+            sig(arguments)
+            unary_minus
+          end
+        elsif operator == "/"
+          sig(arguments) { ::Code::Object::Number }
+          division(value)
+        elsif operator == "*"
+          sig(arguments) { ::Code::Object::Number }
+          multiplication(value)
+        elsif operator == "**"
+          sig(arguments) { ::Code::Object::Number }
+          power(value)
+        elsif operator == "<"
+          sig(arguments) { ::Code::Object::Number }
+          inferior(value)
+        elsif operator == "<="
+          sig(arguments) { ::Code::Object::Number }
+          inferior_or_equal(value)
+        elsif operator == ">"
+          sig(arguments) { ::Code::Object::Number }
+          superior(value)
+        elsif operator == ">="
+          sig(arguments) { ::Code::Object::Number }
+          superior_or_equal(value)
+        elsif operator == "<<"
+          sig(arguments) { ::Code::Object::Number }
+          left_shift(value)
+        elsif operator == ">>"
+          sig(arguments) { ::Code::Object::Number }
+          right_shift(value)
+        elsif operator == "&"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_and(value)
+        elsif operator == "|"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_or(value)
+        elsif operator == "^"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_xor(value)
+        else
+          super
+        end
+      end
+
+      def to_s
+        raw.to_s("F")
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      def modulo(other)
+        ::Code::Object::Decimal.new(raw % other.raw)
+      end
+
+      def plus(other)
+        if other.is_a?(::Code::Object::Number)
+          ::Code::Object::Decimal.new(raw + other.raw)
+        else
+          ::Code::Object::String.new(to_s + other.to_s)
+        end
+      end
+
+      def minus(other)
+        ::Code::Object::Decimal.new(raw - other.raw)
+      end
+
+      def division(other)
+        ::Code::Object::Decimal.new(raw / other.raw)
+      end
+
+      def multiplication(other)
+        ::Code::Object::Decimal.new(raw * other.raw)
+      end
+
+      def power(other)
+        ::Code::Object::Decimal.new(raw**other.raw)
+      end
+
+      def inferior(other)
+        ::Code::Object::Boolean.new(raw < other.raw)
+      end
+
+      def inferior_or_equal(other)
+        ::Code::Object::Boolean.new(raw <= other.raw)
+      end
+
+      def superior(other)
+        ::Code::Object::Boolean.new(raw > other.raw)
+      end
+
+      def superior_or_equal(other)
+        ::Code::Object::Boolean.new(raw >= other.raw)
+      end
+
+      def left_shift(other)
+        ::Code::Object::Integer.new(raw.to_i << other.raw.to_i)
+      end
+
+      def right_shift(other)
+        ::Code::Object::Integer.new(raw.to_i >> other.raw.to_i)
+      end
+
+      def bitwise_and(other)
+        ::Code::Object::Integer.new(raw.to_i & other.raw.to_i)
+      end
+
+      def bitwise_or(other)
+        ::Code::Object::Integer.new(raw.to_i | other.raw.to_i)
+      end
+
+      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

@@ -0,0 +1,96 @@
+class Code
+  class Object
+    class Dictionnary < ::Code::Object
+      attr_reader :raw
+
+      def initialize(raw = {})
+        @raw = raw
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
+
+        if operator == "values"
+          sig(arguments)
+          values
+        elsif operator == "keys"
+          sig(arguments)
+          keys
+        elsif operator == "each"
+          sig(arguments) { ::Code::Object::Function }
+          each(value, **globals)
+        elsif key?(operator)
+          result = fetch(operator)
+
+          if result.is_a?(::Code::Object::Function)
+            result.call(**args.merge(operator: nil))
+          else
+            sig(arguments)
+            result
+          end
+        else
+          super
+        end
+      end
+
+      def merge(other)
+        ::Code::Object::Dictionnary.new(raw.merge(other.raw))
+      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 deep_dup
+        ::Code::Object::Dictionnary.new(raw.deep_dup)
+      end
+
+      def to_s
+        "{#{raw.map { |key, value| "#{key.inspect} => #{value.inspect}" }.join(", ")}}"
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      def keys
+        ::Code::Object::List.new(raw.keys)
+      end
+
+      def values
+        ::Code::Object::List.new(raw.values)
+      end
+
+      def each(argument, **globals)
+        raw.each do |key, value|
+          argument.call(
+            arguments: [
+              ::Code::Object::Argument.new(key),
+              ::Code::Object::Argument.new(value)
+            ],
+            **globals
+          )
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/code/object/function.rb

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

data/lib/code/object/global.rb

@@ -0,0 +1,42 @@
+class Code
+  class Object
+    class Global < ::Code::Object
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        context = args.fetch(:context)
+        io = args.fetch(:io)
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
+
+        if operator == "print"
+          io.print(*arguments.map(&:value))
+          ::Code::Object::Nothing.new
+        elsif operator == "puts"
+          io.puts(*arguments.map(&:value))
+          ::Code::Object::Nothing.new
+        elsif operator == "context"
+          sig(arguments) { ::Code::Object::String }
+          context[value] || ::Code::Object::Nothing.new
+        elsif operator == "evaluate"
+          sig(arguments) { ::Code::Object::String }
+          Code.evaluate(value.raw)
+        else
+          result = context[operator]
+
+          if result && result.is_a?(::Code::Object::Function)
+            result.call(**args.merge(operator: nil))
+          elsif result
+            result
+          else
+            raise ::Code::Error::Undefined.new("#{operator} is not defined")
+          end
+        end
+      end
+
+      def to_s
+        "global"
+      end
+    end
+  end
+end