language-ruby 0.5.6 → 0.6.1

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

data/lib/code/node/ternary.rb

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

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

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

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

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

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

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

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