code-ruby 0.5.6 → 0.6.0

data/lib/code/object/string.rb

@@ -1,74 +1,85 @@
+# frozen_string_literal: true
+
 class Code
   class Object
-    class String < ::Code::Object
+    class String < Object
       attr_reader :raw
 
       def initialize(string)
-        @raw = string
+        @raw = string.to_s
+      end
+
+      def self.name
+        "String"
       end
 
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        globals = multi_fetch(args, *::Code::GLOBALS)
+        globals = multi_fetch(args, *GLOBALS)
         value = arguments.first&.value
 
-        if operator == "&" || operator == "to_function"
-          sig(arguments)
-          to_function(**globals)
-        elsif operator == "+"
-          sig(arguments) { ::Code::Object }
-          plus(value)
-        elsif operator == "*"
-          sig(arguments) { ::Code::Object::Number }
-          multiplication(value)
-        elsif operator == "reverse"
-          sig(arguments)
-          reverse
-        elsif operator == "downcase"
-          sig(arguments)
-          downcase
-        elsif operator == "include?"
-          sig(arguments) { ::Code::Object::String }
-          include?(value)
+        case operator.to_s
+        when "&", "to_function"
+          sig(args)
+          code_to_function(**globals)
+        when "*"
+          sig(args) { Number }
+          code_multiplication(value)
+        when "+"
+          sig(args) { Object }
+          code_plus(value)
+        when "downcase"
+          sig(args)
+          code_downcase
+        when "include?"
+          sig(args) { String }
+          code_include?(value)
+        when "reverse"
+          sig(args)
+          code_reverse
         else
           super
         end
       end
 
-      def succ
-        ::Code::Object::String.new(raw.succ)
+      def code_downcase
+        String.new(raw.downcase)
       end
 
-      def to_sym
-        raw.to_sym
+      def code_include?(value)
+        Boolean.new(raw.include?(value.raw))
       end
 
-      def to_s
-        raw
+      def code_multiplication(other)
+        String.new(raw * other.raw)
       end
 
-      def inspect
-        raw.inspect
+      def code_plus(other)
+        String.new(raw + other.to_s)
       end
 
-      private
+      def code_reverse
+        String.new(raw.reverse)
+      end
 
-      def to_function(**globals)
-        ::Code::Node::Code.new(
+      def code_to_function(**globals)
+        Code::Node::Code.new(
           [
             {
               function: {
                 parameters: [{ name: "_" }],
                 body: [
                   {
-                    chained_call: {
+                    left_operation: {
                       first: {
                         call: {
                           name: "_"
                         }
                       },
-                      others: [{ call: { name: raw } }]
+                      others: [
+                        { operator: ".", statement: { call: { name: raw } } }
+                      ]
                     }
                   }
                 ]
@@ -78,24 +89,16 @@ class Code
         ).evaluate(**globals)
       end
 
-      def plus(other)
-        ::Code::Object::String.new(raw + other.to_s)
-      end
-
-      def multiplication(other)
-        ::Code::Object::String.new(raw * other.raw)
-      end
-
-      def reverse
-        ::Code::Object::String.new(raw.reverse)
+      def inspect
+        raw.inspect
       end
 
-      def downcase
-        ::Code::Object::String.new(raw.downcase)
+      def succ
+        String.new(raw.succ)
       end
 
-      def include?(value)
-        ::Code::Object::Boolean.new(raw.include?(value.raw))
+      def to_s
+        raw
       end
     end
   end

data/lib/code/object.rb

@@ -1,63 +1,26 @@
+# frozen_string_literal: true
+
 class Code
   class Object
-    include Comparable
-
-    def call(**args)
-      operator = args.fetch(:operator, nil)
-      arguments = args.fetch(:arguments, [])
-      value = arguments.first&.value
+    def self.maybe
+      Type::Maybe.new(self)
+    end
 
-      if operator == "=="
-        sig(arguments) { ::Code::Object }
-        equal(value)
-      elsif operator == "==="
-        sig(arguments) { ::Code::Object }
-        strict_equal(value)
-      elsif operator == "!="
-        sig(arguments) { ::Code::Object }
-        different(value)
-      elsif operator == "<=>"
-        sig(arguments) { ::Code::Object }
-        compare(value)
-      elsif operator == "&&" || operator == "and"
-        sig(arguments) { ::Code::Object }
-        and_operator(value)
-      elsif operator == "||" || operator == "or"
-        sig(arguments) { ::Code::Object }
-        or_operator(value)
-      elsif operator == "!" || operator == "not"
-        sig(arguments)
-        exclamation_point
-      elsif operator == "+"
-        sig(arguments)
-        self
-      elsif operator == ".."
-        sig(arguments) { ::Code::Object }
-        inclusive_range(value)
-      elsif operator == "..."
-        sig(arguments) { ::Code::Object }
-        exclusive_range(value)
-      elsif operator == "to_string"
-        sig(arguments)
-        to_string
-      else
-        raise(
-          Code::Error::Undefined.new("#{operator} not defined on #{inspect}")
-        )
-      end
+    def self.name
+      "Object"
     end
 
-    def truthy?
-      true
+    def self.repeat(minimum = 0, maximum = nil)
+      Type::Repeat.new(self, minimum:, maximum:)
     end
 
-    def falsy?
-      !truthy?
+    def self.|(other)
+      Type::Or.new(self, other)
     end
 
     def <=>(other)
       if respond_to?(:raw)
-        other.respond_to?(:raw) ? raw <=> other.raw : raw <=> other
+        raw <=> (other.respond_to?(:raw) ? other.raw : other)
       else
         other <=> self
       end
@@ -65,133 +28,148 @@ class Code
 
     def ==(other)
       if respond_to?(:raw)
-        other.respond_to?(:raw) ? raw == other.raw : raw == other
+        raw == (other.respond_to?(:raw) ? other.raw : other)
       else
         other == self
       end
     end
-    alias_method :eql?, :==
+    alias eql? ==
 
-    def hash
-      if respond_to?(:raw)
-        [self.class, raw].hash
+    def call(**args)
+      operator = args.fetch(:operator, nil)
+      arguments = args.fetch(:arguments, [])
+      value = arguments.first&.value
+
+      case operator.to_s
+      when "!", "not"
+        sig(args)
+        code_exclamation_point
+      when "!=", "different"
+        sig(args) { Object }
+        code_different(value)
+      when "&&", "and"
+        sig(args) { Object }
+        code_and_operator(value)
+      when "+", "self"
+        sig(args)
+        code_self
+      when "..", "inclusive_range"
+        sig(args) { Object }
+        code_inclusive_range(value)
+      when "...", "exclusive_range"
+        sig(args) { Object }
+        code_exclusive_range(value)
+      when "==", "equal"
+        sig(args) { Object }
+        code_equal_equal(value)
+      when "===", "strict_equal"
+        sig(args) { Object }
+        code_equal_equal_equal(value)
+      when "falsy?"
+        sig(args)
+        Boolean.new(falsy?)
+      when "to_string"
+        sig(args)
+        code_to_string
+      when "truthy?"
+        sig(args)
+        Boolean.new(truthy?)
+      when "||", "or"
+        sig(args) { Object }
+        code_or_operator(value)
+      when /=$/
+        sig(args) { Object }
+
+        if operator == "="
+          context = args[:context]
+          context.code_set(self, value)
+        else
+          context = args[:context].lookup!(self)
+          context.code_set(
+            self,
+            context.code_fetch(self).call(
+              **args,
+              operator: operator[..-2],
+              arguments: [Argument.new(value)]
+            )
+          )
+        end
+
+        context.code_fetch(self)
       else
-        raise NotImplementedError.new(self.class.name)
+        raise(
+          Code::Error::Undefined,
+          "#{operator} not defined on #{inspect}:#{self.class.name}"
+        )
       end
     end
 
-    def to_s
-      raise NotImplementedError.new(self.class.name)
+    def code_and_operator(other)
+      truthy? ? other : self
     end
 
-    private
-
-    def multi_fetch(hash, *keys)
-      keys.map { |key| [key, hash.fetch(key)] }.to_h
+    def code_different(other)
+      Boolean.new(self != other)
     end
 
-    def deep_dup(object)
-      if object.is_a?(Array)
-        object.map { |element| deep_dup(element) }
-      elsif object.is_a?(Hash)
-        object.map { |key, value| [deep_dup(key), deep_dup(value)] }.to_h
-      elsif object.is_a?(::Code::Object::List)
-        ::Code::Object::List.new(object.raw.map { |element| deep_dup(element) })
-      elsif object.is_a?(::Code::Object::Dictionnary)
-        ::Code::Object::Dictionnary.new(
-          object.raw.map { |key, value| [deep_dup(key), deep_dup(value)] }.to_h
-        )
-      else
-        object.dup
-      end
+    def code_equal_equal(other)
+      Boolean.new(self == other)
     end
 
-    def sig(actual_arguments, &block)
-      if block
-        expected_arguments = block.call
-        expected_arguments = [
-          expected_arguments
-        ] unless expected_arguments.is_a?(Array)
-      else
-        expected_arguments = []
-      end
+    def code_exclamation_point
+      truthy? ? Object::Boolean.new(false) : Object::Boolean.new(true)
+    end
 
-      if actual_arguments.size != expected_arguments.size
-        raise(
-          ::Code::Error::ArgumentError.new(
-            "Expected #{expected_arguments.size} arguments, " \
-              "got #{actual_arguments.size} arguments"
-          )
-        )
-      end
+    def code_exclusive_range(value)
+      Range.new(self, value, exclude_end: true)
+    end
 
-      expected_arguments.each.with_index do |expected_argument, index|
-        actual_argument = actual_arguments[index].value
-
-        if expected_argument.is_a?(Array)
-          if expected_argument.none? { |expected_arg|
-               actual_argument.is_a?(expected_arg)
-             }
-            raise(
-              ::Code::Error::TypeError.new(
-                "Expected #{expected_argument}, got #{actual_argument.class}"
-              )
-            )
-          end
-        else
-          if !actual_argument.is_a?(expected_argument)
-            raise(
-              ::Code::Error::TypeError.new(
-                "Expected #{expected_argument}, got #{actual_argument.class}"
-              )
-            )
-          end
-        end
-      end
+    def code_inclusive_range(value)
+      Range.new(self, value, exclude_end: false)
     end
 
-    def equal(other)
-      ::Code::Object::Boolean.new(self == other)
+    def code_or_operator(other)
+      truthy? ? self : other
     end
 
-    def strict_equal(other)
-      ::Code::Object::Boolean.new(self === other)
+    def code_self
+      self
     end
 
-    def different(other)
-      ::Code::Object::Boolean.new(self != other)
+    def code_equal_equal_equal(other)
+      Boolean.new(self === other)
     end
 
-    def compare(other)
-      ::Code::Object::Integer.new(self <=> other)
+    def code_to_string
+      String.new(to_s)
     end
 
-    def and_operator(other)
-      truthy? ? other : self
+    def falsy?
+      !truthy?
     end
 
-    def or_operator(other)
-      truthy? ? self : other
+    def hash
+      unless respond_to?(:raw)
+        raise NotImplementedError, "#{self.class.name}#hash"
+      end
+
+      [self.class, raw].hash
     end
 
-    def to_string
-      ::Code::Object::String.new(to_s)
+    def multi_fetch(hash, *keys)
+      keys.map { |key| [key, hash.fetch(key)] }.to_h
     end
 
-    def inclusive_range(value)
-      ::Code::Object::Range.new(self, value, exclude_end: false)
+    def sig(args, &block)
+      Type::Sig.sig(args, object: self, &block)
     end
 
-    def exclusive_range(value)
-      ::Code::Object::Range.new(self, value, exclude_end: true)
+    def to_s
+      raise NotImplementedError, "#{self.class.name}#to_s"
     end
 
-    def exclamation_point
-      if truthy?
-        ::Code::Object::Boolean.new(false)
-      else
-        ::Code::Object::Boolean.new(true)
-      end
+    def truthy?
+      true
     end
   end
 end

data/lib/code/parser/addition.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class Addition < Operation
+    class Addition < LeftOperation
       def statement
-        ::Code::Parser::Multiplication
+        Multiplication
       end
 
       def plus

data/lib/code/parser/and_operator.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class AndOperator < Operation
+    class AndOperator < LeftOperation
       def statement
-        ::Code::Parser::EqualityLower
+        Equality
       end
 
       def ampersand

data/lib/code/parser/bitwise_and.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class BitwiseAnd < Operation
+    class BitwiseAnd < LeftOperation
       def statement
-        ::Code::Parser::Shift
+        Shift
       end
 
       def ampersand

data/lib/code/parser/bitwise_or.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class BitwiseOr < Operation
+    class BitwiseOr < LeftOperation
       def statement
-        ::Code::Parser::BitwiseAnd
+        BitwiseAnd
       end
 
       def pipe

data/lib/code/parser/boolean.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Boolean < Language
@@ -10,7 +12,7 @@ class Code
       end
 
       def root
-        (true_keyword | false_keyword).aka(:boolean) | ::Code::Parser::Nothing
+        (true_keyword | false_keyword).aka(:boolean) | Nothing
       end
     end
   end

data/lib/code/parser/call.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Call < Language
       def name
-        ::Code::Parser::Name
+        Name
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def whitespace?
@@ -14,11 +16,11 @@ class Code
       end
 
       def code
-        ::Code::Parser::Code
+        Code
       end
 
       def code_present
-        ::Code::Parser::Code.new.present
+        Code.new.present
       end
 
       def colon
@@ -62,7 +64,7 @@ class Code
       end
 
       def keyword_argument
-        name.aka(:name) << colon << code_present.aka(:value)
+        name.aka(:name) << whitespace? << colon << code.aka(:value)
       end
 
       def regular_argument
@@ -74,9 +76,11 @@ class Code
       end
 
       def arguments
-        opening_parenthesis.ignore << whitespace? << argument.repeat(0, 1) <<
-          (comma << whitespace? << argument << whitespace?).repeat <<
-          whitespace? << closing_parenthesis.ignore.maybe
+        opening_parenthesis.ignore << whitespace? <<
+          (
+            whitespace? << argument <<
+              (whitespace? << comma << whitespace?).maybe
+          ).repeat << whitespace? << closing_parenthesis.ignore.maybe
       end
 
       def keyword_parameter
@@ -94,9 +98,11 @@ class Code
       end
 
       def parameters
-        pipe.ignore << whitespace? << parameter.repeat(0, 1) <<
-          (whitespace? << comma << whitespace? << parameter).repeat <<
-          whitespace? << pipe.ignore.maybe
+        pipe.ignore << whitespace? <<
+          (
+            whitespace? << parameter <<
+              (whitespace? << comma << whitespace?).maybe
+          ).repeat << (whitespace? << pipe.ignore).maybe
       end
 
       def block

data/lib/code/parser/chained_call.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class ChainedCall < Operation
+    class ChainedCall < LeftOperation
       def statement
-        ::Code::Parser::Dictionnary
+        SquareBracket
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def whitespace?
@@ -17,30 +19,16 @@ class Code
         str(".")
       end
 
+      def ampersand
+        str("&")
+      end
+
       def colon
         str(":")
       end
 
       def operator
-        dot | (colon << colon)
-      end
-
-      def root
-        (
-          statement.aka(:first) <<
-            (whitespace? << operator << whitespace? << statement)
-              .repeat(1)
-              .aka(:others)
-              .maybe
-        )
-          .aka(:chained_call)
-          .then do |output|
-            if output[:chained_call][:others]
-              output
-            else
-              output[:chained_call][:first]
-            end
-          end
+        dot | (colon << colon) | (ampersand << dot)
       end
     end
   end