code-ruby 0.5.6 → 0.6.0

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