code-ruby 0.5.6 → 0.6.1

data/lib/code/node/left_operation.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class Code
+  class Node
+    class LeftOperation < Node
+      class Operator < Node
+        DOT = "."
+        COLON_COLON = "::"
+
+        attr_reader :operator, :statement
+
+        def initialize(parsed)
+          @operator = parsed.delete(:operator)
+          @statement = Statement.new(parsed.delete(:statement))
+        end
+
+        def call?
+          operator == DOT || operator == COLON_COLON
+        end
+      end
+
+      def initialize(parsed)
+        @first = Statement.new(parsed.delete(:first))
+        @others =
+          parsed.delete(:others).map { |operator| Operator.new(operator) }
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        first = @first.evaluate(**args)
+
+        @others.reduce(first) do |left, right|
+          if right.call?
+            right.statement.evaluate(**args, object: left)
+          else
+            statement = right.statement.evaluate(**args)
+
+            left.call(
+              **args,
+              operator: right.operator,
+              arguments: [::Code::Object::Argument.new(statement)]
+            )
+          end
+        end
+      end
+
+      def resolve(**args)
+        first = @first.resolve(**args)
+
+        list = Object::IdentifierList.new([first])
+
+        @others.each do |other|
+          list.code_append(
+            other.statement.resolve(**args, object: list.code_last)
+          )
+        end
+
+        list
+      end
+    end
+  end
+end

data/lib/code/node/list.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Node
     class List < Node

data/lib/code/node/negation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Node
     class Negation < Node

data/lib/code/node/not.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Node
     class Not < Node

data/lib/code/node/nothing.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 class Code
   class Node
     class Nothing < Node
       def initialize(parsed)
       end
 
-      def evaluate(**args)
+      def evaluate(**_args)
         ::Code::Object::Nothing.new
       end
     end

data/lib/code/node/number.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Node
     class Number < Node

data/lib/code/node/right_operation.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class Code
+  class Node
+    class RightOperation < Node
+      EQUAL = "="
+
+      def initialize(parsed)
+        @left = Statement.new(parsed.delete(:left))
+        @operator = parsed.delete(:operator)
+        @right = Statement.new(parsed.delete(:right))
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        case @operator
+        when "if"
+          if @right.evaluate(**args).truthy?
+            @left.evaluate(**args)
+          else
+            Object::Nothing.new
+          end
+        when "unless"
+          if @right.evaluate(**args).truthy?
+            Object::Nothing.new
+          else
+            @left.evaluate(**args)
+          end
+        when "while"
+          left = Object::Nothing.new
+
+          left = @left.evaluate(**args) while @right.evaluate(**args).truthy?
+
+          left
+        when "until"
+          left = Object::Nothing.new
+
+          left = @left.evaluate(**args) while @right.evaluate(**args).falsy?
+
+          left
+        when "rescue"
+          begin
+            @left.evaluate(**args)
+          rescue Error
+            @right.evaluate(**args)
+          end
+        when /=$/
+          right = @right.evaluate(**args)
+          left = @left.resolve(**args)
+
+          left.call(
+            operator: @operator,
+            arguments: [Object::Argument.new(right)],
+            **args
+          )
+        else
+          right = @right.evaluate(**args)
+          left = @left.evaluate(**args)
+
+          left.call(
+            operator: @operator,
+            arguments: [Object::Argument.new(right)],
+            **args
+          )
+        end
+      end
+    end
+  end
+end

data/lib/code/node/splat.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Node
     class Splat < Node

data/lib/code/node/square_bracket.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Code
+  class Node
+    class SquareBracket < Node
+      def initialize(parsed)
+        @left = Node::Statement.new(parsed.delete(:left))
+        @statements =
+          parsed
+            .delete(:statements)
+            .map { |statement| Node::Statement.new(statement) }
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        left = @left.evaluate(**args)
+
+        @statements.reduce(left) do |object, statement|
+          object.code_fetch(statement.evaluate(**args))
+        end
+      end
+
+      def resolve(**args)
+        left = @left.resolve(**args)
+
+        list = Object::IdentifierList.new([left])
+
+        @statements.each do |statement|
+          list.code_append(statement.evaluate(**args))
+        end
+
+        list
+      end
+    end
+  end
+end

data/lib/code/node/statement.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Node
     class Statement < Node
@@ -17,13 +19,13 @@ class Code
         elsif parsed.key?(:list)
           @statement = Node::List.new(parsed.delete(:list))
         elsif parsed.key?(:dictionnary)
-          @statement = Node::Dictionnary.new(parsed.delete(:dictionnary))
+          @statement = Node::Dictionary.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?(:left_operation)
+          @statement = Node::LeftOperation.new(parsed.delete(:left_operation))
+        elsif parsed.key?(:right_operation)
+          @statement = Node::RightOperation.new(parsed.delete(:right_operation))
         elsif parsed.key?(:function)
           @statement = Node::Function.new(parsed.delete(:function))
         elsif parsed.key?(:negation)
@@ -46,6 +48,8 @@ class Code
           @statement = Node::While.new(parsed.delete(:while))
         elsif parsed.key?(:splat)
           @statement = Node::Splat.new(parsed.delete(:splat))
+        elsif parsed.key?(:square_bracket)
+          @statement = Node::SquareBracket.new(parsed.delete(:square_bracket))
         end
 
         super(parsed)
@@ -54,6 +58,10 @@ class Code
       def evaluate(**args)
         @statement.evaluate(**args)
       end
+
+      def resolve(**args)
+        @statement.resolve(**args)
+      end
     end
   end
 end

data/lib/code/node/string.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Node
     class String < Node
@@ -17,7 +19,7 @@ class Code
             @text = parsed
           end
 
-          def evaluate(**args)
+          def evaluate(**_args)
             ::Code::Object::String.new(@text)
           end
         end

data/lib/code/node/ternary.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 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
+        @right = Node::Statement.new(parsed.delete(:right)) if parsed.key?(
+          :right
+        )
         super(parsed)
       end
 

data/lib/code/node/unary_minus.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Node
     class UnaryMinus < Node

data/lib/code/node/while.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Node
     class While < Node
@@ -15,9 +17,9 @@ class Code
         if @operator == WHILE_KEYWORD
           last = ::Code::Object::Nothing.new
 
-          while @statement.evaluate(**args).truthy?
-            last = @body.evaluate(**args)
-          end
+          last = @body.evaluate(**args) while @statement.evaluate(
+            **args
+          ).truthy?
 
           last
         elsif @operator == UNTIL_KEYWORD
@@ -27,7 +29,7 @@ class Code
 
           last
         else
-          raise NotImplementedError.new(@operator)
+          raise NotImplementedError, @operator
         end
       end
     end

data/lib/code/node.rb

@@ -1,13 +1,19 @@
+# frozen_string_literal: true
+
 class Code
   class Node
     def initialize(parsed)
-      if parsed.any?
-        raise NotImplementedError.new(self.class.name + ": " + parsed.inspect)
-      end
+      return unless parsed.any?
+
+      raise NotImplementedError, "#{self.class.name}: #{parsed.inspect}"
+    end
+
+    def evaluate(**_args)
+      raise NotImplementedError, "#{self.class.name}#evaluate"
     end
 
-    def evaluate(**args)
-      raise NotImplementedError.new(self.class.name + "#evaluate")
+    def resolve(...)
+      evaluate(...)
     end
   end
 end

data/lib/code/object/argument.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 class Code
   class Object
-    class Argument
+    class Argument < Object
       attr_reader :value, :name
 
       def initialize(value, name: nil)
@@ -8,8 +10,12 @@ class Code
         @name = name
       end
 
-      def regular?
-        !name
+      def self.name
+        "Argument"
+      end
+
+      def inspect
+        to_s
       end
 
       def keyword?
@@ -20,12 +26,12 @@ class Code
         [name, value]
       end
 
-      def to_s
-        "<Argument #{value.inspect}>"
+      def regular?
+        !name
       end
 
-      def inspect
-        to_s
+      def to_s
+        "<Argument #{value.inspect}>"
       end
     end
   end

data/lib/code/object/boolean.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Object
     class Boolean < ::Code::Object
@@ -7,20 +9,56 @@ class Code
         @raw = raw
       end
 
-      def truthy?
-        raw
+      def self.name
+        "Boolean"
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        value = arguments.first&.value
+
+        case operator.to_s
+        when "&", "bitwise_and"
+          sig(args) { Boolean }
+          code_bitwise_and(value)
+        when "^", "bitwise_xor"
+          sig(args) { Boolean }
+          code_bitwise_xor(value)
+        when "|", "bitwise_or"
+          sig(args) { Boolean }
+          code_bitwise_or(value)
+        else
+          super
+        end
+      end
+
+      def code_bitwise_and(value)
+        Boolean.new(raw & value.raw)
+      end
+
+      def code_bitwise_or(value)
+        Boolean.new(raw | value.raw)
+      end
+
+      def code_bitwise_xor(value)
+        Boolean.new(raw ^ value.raw)
+      end
+
+      def inspect
+        to_s
       end
 
       def succ
-        ::Code::Object::Boolean.new(!raw)
+        Boolean.new(!raw)
       end
 
       def to_s
         raw.to_s
       end
 
-      def inspect
-        to_s
+      def truthy?
+        raw
       end
     end
   end

data/lib/code/object/class.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Code
+  class Object
+    class Class < Object
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def self.name
+        "Class"
+      end
+    end
+  end
+end

data/lib/code/object/context.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Code
+  class Object
+    class Context < Dictionary
+      attr_reader :parent
+
+      def initialize(raw = {}, parent: nil)
+        @raw = raw
+        @parent = parent
+      end
+
+      def self.name
+        "Context"
+      end
+
+      def lookup!(identifier)
+        if code_has_key?(identifier).truthy?
+          self
+        elsif parent?
+          parent.lookup!(identifier)
+        else
+          raise Code::Error::Undefined, "#{identifier} is not defined"
+        end
+      end
+
+      def merge(other)
+        Context.new(raw.merge(other.raw), parent: parent || other.parent)
+      end
+
+      def parent?
+        !!parent
+      end
+    end
+  end
+end