code-ruby 0.2.4

data/lib/code/node/operation.rb

@@ -0,0 +1,33 @@
+class Code
+  class Node
+    class Operation < Node
+      class Operation
+        attr_reader :operator, :statement
+
+        def initialize(operation)
+          @operator = operation.fetch(:operator).to_s
+          @statement = ::Code::Node::Statement.new(operation.fetch(: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
+      end
+
+      def evaluate(**args)
+        object = @first.evaluate(**args)
+
+        @rest.each do |operation|
+          other = operation.statement.evaluate(**args)
+          object = simple_call(object, operation.operator, other, **args)
+        end
+
+        object
+      end
+    end
+  end
+end

data/lib/code/node/or_keyword.rb

@@ -0,0 +1,34 @@
+class Code
+  class Node
+    class OrKeyword < Node
+      OR_KEYWORD = "or"
+      AND_KEYWORD = "and"
+
+      def initialize(or_keyword)
+        @first = ::Code::Node::Statement.new(or_keyword.fetch(:first))
+        @rest = or_keyword.fetch(:rest)
+        @rest.map! do |operation|
+          ::Code::Node::Operation::Operation.new(operation)
+        end
+      end
+
+      def evaluate(**args)
+        object = @first.evaluate(**args)
+
+        @rest.each do |operation|
+          if operation.operator == OR_KEYWORD
+            return object if object.truthy?
+          elsif operation.operator == AND_KEYWORD
+            return object unless object.truthy?
+          else
+            raise NotImplementedError.new(operation.operator.inspect)
+          end
+
+          object = operation.statement.evaluate(**args)
+        end
+
+        object
+      end
+    end
+  end
+end

data/lib/code/node/power.rb

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

data/lib/code/node/range.rb

@@ -0,0 +1,31 @@
+class Code
+  class Node
+    class Range < Node
+      INCLUSIVE_RANGE = ".."
+      EXCLUSIVE_RANGE = "..."
+
+      def initialize(range)
+        @left = ::Code::Node::Statement.new(range.fetch(:left))
+        @operator = range.fetch(:operator)
+        @right = ::Code::Node::Statement.new(range.fetch(:right))
+      end
+
+      def evaluate(**args)
+        left = @left.evaluate(**args)
+        right = @right.evaluate(**args)
+
+        if operator == INCLUSIVE_RANGE
+          ::Code::Object::Range.new(left, right, exclude_end: false)
+        elsif operator == EXCLUSIVE_RANGE
+          ::Code::Object::Range.new(left, right, exclude_end: true)
+        else
+          raise NotImplementedError.new(operator)
+        end
+      end
+
+      private
+
+      attr_reader :operator
+    end
+  end
+end

data/lib/code/node/regular_call_argument.rb

@@ -0,0 +1,34 @@
+class Code
+  class Node
+    class RegularCallArgument < Node
+      def initialize(argument)
+        @splat = argument.key?(:splat)
+        @keyword_splat = argument.key?(:keyword_splat)
+        @block = argument.key?(:block)
+        @value = ::Code::Node::Code.new(argument.fetch(:value))
+      end
+
+      def evaluate(**args)
+        object = @value.evaluate(**args)
+
+        block? ? simple_call(object, :to_function, **args) : object
+      end
+
+      def block?
+        @block
+      end
+
+      def splat?
+        @splat
+      end
+
+      def keyword_splat?
+        @keyword_splat
+      end
+
+      def name
+        nil
+      end
+    end
+  end
+end

data/lib/code/node/regular_function_argument.rb

@@ -0,0 +1,36 @@
+class Code
+  class Node
+    class RegularFunctionArgument < Node
+      def initialize(argument)
+        @block = argument.key?(:block)
+        @splat = argument.key?(:splat)
+        @keyword_splat = argument.key?(:keyword_splat)
+        @name = argument.fetch(:name)
+
+        if argument.key?(:default)
+          @default = ::Code::Node::Code.new(argument.fetch(:default))
+        end
+      end
+
+      def evaluate(**args)
+        @default ? @default.evaluate(**args) : ::Code::Object::Nothing.new
+      end
+
+      def name
+        ::Code::Object::String.new(@name.to_s)
+      end
+
+      def splat?
+        @splat
+      end
+
+      def keyword_splat?
+        @keyword_splat
+      end
+
+      def block?
+        @block
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+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)
+        end
+      end
+
+      def evaluate(**args)
+        @statement.evaluate(**args)
+      end
+    end
+  end
+end

data/lib/code/node/string.rb

@@ -0,0 +1,17 @@
+class Code
+  class Node
+    class String < Node
+      def initialize(string)
+        @string = string
+      end
+
+      def evaluate(**args)
+        ::Code::Object::String.new(string.to_s)
+      end
+
+      private
+
+      attr_reader :string
+    end
+  end
+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

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

@@ -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,54 @@
+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, [])
+
+        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
+        raw.to_s("F")
+      end
+
+      def inspect
+        to_s
+      end
+
+      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
+
+      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
+end

data/lib/code/object/dictionnary.rb

@@ -0,0 +1,55 @@
+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, [])
+
+        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
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      def values(arguments)
+        sig(arguments)
+        ::Code::Object::List.new(raw.values)
+      end
+    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