code-ruby 0.3.1 → 0.5.0

data/lib/code/object.rb

@@ -5,38 +5,48 @@ class Code
     def call(**args)
       operator = args.fetch(:operator, nil)
       arguments = args.fetch(:arguments, [])
-      if %w[== === !=].detect { |o| operator == o }
-        comparaison(operator.to_sym, arguments)
+      value = arguments.first&.value
+
+      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 == "<=>"
-        compare(arguments)
-      elsif operator == "&&"
-        and_operator(arguments)
-      elsif operator == "||"
-        or_operator(arguments)
+        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"
-        to_string(arguments)
+        sig(arguments)
+        to_string
       else
-        raise ::Code::Error::Undefined.new(
-                "#{operator} not defined on #{inspect}",
-              )
+        raise(
+          Code::Error::Undefined.new("#{operator} not defined on #{inspect}")
+        )
       end
     end
 
-    def []=(key, value)
-      @attributes ||= {}
-      @attributes[key] = value
-    end
-
-    def [](key)
-      @attributes ||= {}
-      @attributes[key]
-    end
-
-    def key?(key)
-      @attributes ||= {}
-      @attributes.key?(key)
-    end
-
     def truthy?
       true
     end
@@ -66,22 +76,53 @@ class Code
       if respond_to?(:raw)
         [self.class, raw].hash
       else
-        raise NotImplementedError
+        raise NotImplementedError.new(self.class.name)
       end
     end
 
     def to_s
-      raise NotImplementedError
+      raise NotImplementedError.new(self.class.name)
     end
 
     private
 
-    def sig(actual_arguments, *expected_arguments)
+    def multi_fetch(hash, *keys)
+      keys.map { |key| [key, hash.fetch(key)] }.to_h
+    end
+
+    def deep_dup(object)
+      if object.is_a?(Array)
+        object.map { |element| deep_dup(o) }
+      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(o) })
+      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
+    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
+
       if actual_arguments.size != expected_arguments.size
-        raise ::Code::Error::ArgumentError.new(
-                "Expected #{expected_arguments.size} arguments, " \
-                  "got #{actual_arguments.size} arguments",
-              )
+        raise(
+          ::Code::Error::ArgumentError.new(
+            "Expected #{expected_arguments.size} arguments, " \
+              "got #{actual_arguments.size} arguments"
+          )
+        )
       end
 
       expected_arguments.each.with_index do |expected_argument, index|
@@ -91,47 +132,66 @@ class Code
           if expected_argument.none? { |expected_arg|
                actual_argument.is_a?(expected_arg)
              }
-            raise ::Code::Error::TypeError.new(
-                    "Expected #{expected_argument}, got #{actual_argument.class}",
-                  )
+            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}",
-                  )
+            raise(
+              ::Code::Error::TypeError.new(
+                "Expected #{expected_argument}, got #{actual_argument.class}"
+              )
+            )
           end
         end
       end
     end
 
-    def comparaison(operator, arguments)
-      sig(arguments, ::Code::Object)
-      other = arguments.first.value
-      ::Code::Object::Boolean.new(public_send(operator, other))
+    def equal(other)
+      ::Code::Object::Boolean.new(self == other)
+    end
+
+    def strict_equal(other)
+      ::Code::Object::Boolean.new(self === other)
     end
 
-    def compare(arguments)
-      sig(arguments, ::Code::Object)
-      other = arguments.first.value
+    def different(other)
+      ::Code::Object::Boolean.new(self != other)
+    end
+
+    def compare(other)
       ::Code::Object::Integer.new(self <=> other)
     end
 
-    def and_operator(arguments)
-      sig(arguments, ::Code::Object)
-      other = arguments.first.value
+    def and_operator(other)
       truthy? ? other : self
     end
 
-    def or_operator(arguments)
-      sig(arguments, ::Code::Object)
-      other = arguments.first.value
+    def or_operator(other)
       truthy? ? self : other
     end
 
-    def to_string(arguments)
-      sig(arguments)
+    def to_string
       ::Code::Object::String.new(to_s)
     end
+
+    def inclusive_range(value)
+      ::Code::Object::Range.new(self, value, exclude_end: false)
+    end
+
+    def exclusive_range(value)
+      ::Code::Object::Range.new(self, value, exclude_end: true)
+    end
+
+    def exclamation_point
+      if truthy?
+        ::Code::Object::Boolean.new(false)
+      else
+        ::Code::Object::Boolean.new(true)
+      end
+    end
   end
 end

data/lib/code/parser/addition.rb

@@ -1,29 +1,21 @@
 class Code
   class Parser
-    class Addition < Parslet::Parser
-      rule(:multiplication) { ::Code::Parser::Multiplication.new }
-
-      rule(:plus) { str("+") }
-      rule(:minus) { str("-") }
-
-      rule(:operator) { plus | minus }
+    class Addition < Operation
+      def statement
+        ::Code::Parser::Multiplication
+      end
 
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
+      def plus
+        str("+")
+      end
 
-      rule(:addition) do
-        (
-          multiplication.as(:first) >>
-            (
-              whitespace? >> operator.as(:operator) >> whitespace? >>
-                multiplication.as(:statement)
-            ).repeat(1).as(:rest)
-        ).as(:addition) | multiplication
+      def minus
+        str("-")
       end
 
-      root(:addition)
+      def operator
+        plus | minus
+      end
     end
   end
 end

data/lib/code/parser/and_operator.rb

@@ -1,28 +1,17 @@
 class Code
   class Parser
-    class AndOperator < Parslet::Parser
-      rule(:greater_than) { ::Code::Parser::GreaterThan.new }
-
-      rule(:ampersand) { str("&") }
-
-      rule(:operator) { ampersand >> ampersand }
-
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
+    class AndOperator < Operation
+      def statement
+        ::Code::Parser::EqualityLower
+      end
 
-      rule(:and_operator) do
-        (
-          greater_than.as(:first) >>
-            (
-              whitespace? >> operator.as(:operator) >> whitespace? >>
-                greater_than.as(:statement)
-            ).repeat(1).as(:rest)
-        ).as(:and_operator) | greater_than
+      def ampersand
+        str("&")
       end
 
-      root(:and_operator)
+      def operator
+        ampersand << ampersand
+      end
     end
   end
 end

data/lib/code/parser/bitwise_and.rb

@@ -1,28 +1,17 @@
 class Code
   class Parser
-    class BitwiseAnd < Parslet::Parser
-      rule(:shift) { ::Code::Parser::Shift.new }
-
-      rule(:ampersand) { str("&") }
-
-      rule(:operator) { ampersand }
-
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
+    class BitwiseAnd < Operation
+      def statement
+        ::Code::Parser::Shift
+      end
 
-      rule(:bitwise_and) do
-        (
-          shift.as(:first) >>
-            (
-              whitespace? >> operator.as(:operator) >> whitespace? >>
-                shift.as(:statement)
-            ).repeat(1).as(:rest)
-        ).as(:bitwise_and) | shift
+      def ampersand
+        str("&")
       end
 
-      root(:bitwise_and)
+      def operator
+        ampersand
+      end
     end
   end
 end

data/lib/code/parser/bitwise_or.rb

@@ -1,29 +1,21 @@
 class Code
   class Parser
-    class BitwiseOr < Parslet::Parser
-      rule(:bitwise_and) { ::Code::Parser::BitwiseAnd.new }
-
-      rule(:pipe) { str("|") }
-      rule(:caret) { str("^") }
-
-      rule(:operator) { pipe | caret }
+    class BitwiseOr < Operation
+      def statement
+        ::Code::Parser::BitwiseAnd
+      end
 
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
+      def pipe
+        str("|")
+      end
 
-      rule(:bitwise_or) do
-        (
-          bitwise_and.as(:first) >>
-            (
-              whitespace? >> operator.as(:operator) >> whitespace? >>
-                bitwise_and.as(:statement)
-            ).repeat(1).as(:rest)
-        ).as(:bitwise_or) | bitwise_and
+      def caret
+        str("^")
       end
 
-      root(:bitwise_or)
+      def operator
+        pipe | caret
+      end
     end
   end
 end

data/lib/code/parser/boolean.rb

@@ -1,14 +1,17 @@
 class Code
   class Parser
-    class Boolean < Parslet::Parser
-      rule(:nothing) { ::Code::Parser::Nothing.new }
+    class Boolean < Language
+      def true_keyword
+        str("true")
+      end
 
-      rule(:true_keyword) { str("true") }
-      rule(:false_keyword) { str("false") }
+      def false_keyword
+        str("false")
+      end
 
-      rule(:boolean) { (true_keyword | false_keyword).as(:boolean) | nothing }
-
-      root(:boolean)
+      def root
+        (true_keyword | false_keyword).aka(:boolean) | ::Code::Parser::Nothing
+      end
     end
   end
 end

data/lib/code/parser/call.rb

@@ -1,90 +1,122 @@
 class Code
   class Parser
-    class Call < Parslet::Parser
-      rule(:dictionnary) { ::Code::Parser::Dictionnary.new }
-      rule(:code) { ::Code::Parser::Code.new.present }
-      rule(:name) { ::Code::Parser::Name.new }
-      rule(:function_arguments) { ::Code::Parser::Function.new.arguments }
+    class Call < Language
+      def name
+        ::Code::Parser::Name
+      end
 
-      rule(:dot) { str(".") }
-      rule(:opening_parenthesis) { str("(") }
-      rule(:closing_parenthesis) { str(")") }
-      rule(:opening_curly_bracket) { str("{") }
-      rule(:closing_curly_bracket) { str("}") }
-      rule(:comma) { str(",") }
-      rule(:colon) { str(":") }
-      rule(:ampersand) { str("&") }
-      rule(:asterisk) { str("*") }
-      rule(:pipe) { str("|") }
-      rule(:do_keyword) { str("do") }
-      rule(:end_keyword) { str("end") }
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
 
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
+      def whitespace?
+        whitespace.maybe
+      end
 
-      rule(:keyword_argument) do
-        name >> whitespace? >> colon >> whitespace? >> code.as(:value)
+      def code
+        ::Code::Parser::Code
       end
 
-      rule(:regular_argument) do
-        ampersand.as(:block).maybe >>
-          (asterisk >> asterisk).as(:keyword_splat).maybe >>
-          asterisk.as(:splat).maybe >> code.as(:value)
+      def code_present
+        ::Code::Parser::Code.new.present
       end
 
-      rule(:argument) do
-        keyword_argument.as(:keyword) | regular_argument.as(:regular)
+      def colon
+        str(":")
       end
 
-      rule(:arguments) do
-        argument.repeat(1, 1) >>
-          (whitespace? >> comma >> whitespace? >> argument).repeat
+      def comma
+        str(",")
       end
 
-      rule(:single_call) do
-        dictionnary.as(:left) >>
-          (
-            opening_parenthesis >> whitespace? >>
-              arguments.as(:arguments).maybe >> whitespace? >>
-              closing_parenthesis
-          ) >> block.as(:block).maybe
+      def pipe
+        str("|")
       end
 
-      rule(:chained_single_call) do
-        dot >> name >>
-          (
-            opening_parenthesis >> whitespace? >>
-              arguments.as(:arguments).maybe >> whitespace? >>
-              closing_parenthesis
-          ).maybe >> block.as(:block).maybe
+      def equal
+        str("=")
+      end
+
+      def opening_curly_bracket
+        str("{")
+      end
+
+      def closing_curly_bracket
+        str("}")
+      end
+
+      def opening_parenthesis
+        str("(")
+      end
+
+      def closing_parenthesis
+        str(")")
+      end
+
+      def do_keyword
+        str("do")
+      end
+
+      def end_keyword
+        str("end")
+      end
+
+      def keyword_argument
+        name.aka(:name) << colon << code_present.aka(:value)
+      end
+
+      def regular_argument
+        code_present.aka(:value)
+      end
+
+      def argument
+        keyword_argument | regular_argument
+      end
+
+      def arguments
+        opening_parenthesis.ignore << whitespace? << argument.repeat(0, 1) <<
+          (comma << whitespace? << argument << whitespace?).repeat <<
+          whitespace? << closing_parenthesis.ignore.maybe
+      end
+
+      def keyword_parameter
+        name.aka(:name) << whitespace? << colon.aka(:keyword) <<
+          code_present.aka(:default).maybe
+      end
+
+      def regular_parameter
+        name.aka(:name) << whitespace? <<
+          (equal << whitespace? << code_present.aka(:default)).maybe
       end
 
-      rule(:chained_call) do
-        dictionnary.as(:left) >> chained_single_call.repeat(1).as(:right)
+      def parameter
+        keyword_parameter | regular_parameter
       end
 
-      rule(:block_arguments) do
-        pipe >> whitespace? >> function_arguments >> whitespace? >> pipe
+      def parameters
+        pipe.ignore << whitespace? << parameter.repeat(0, 1) <<
+          (whitespace? << comma << whitespace? << parameter).repeat <<
+          whitespace? << pipe.ignore.maybe
       end
 
-      rule(:block) do
+      def block
         (
-          whitespace >> do_keyword >> whitespace >>
-            block_arguments.as(:arguments).maybe >> code.as(:body).maybe >>
-            end_keyword
+          do_keyword << whitespace? << parameters.aka(:parameters).maybe <<
+            code.aka(:body) << end_keyword.maybe
         ) |
           (
-            whitespace? >> opening_curly_bracket >> whitespace >>
-              block_arguments.as(:arguments).maybe >> code.as(:body).maybe >>
-              closing_curly_bracket
+            opening_curly_bracket << whitespace? <<
+              parameters.aka(:parameters).maybe << code.aka(:body) <<
+              closing_curly_bracket.maybe
           )
       end
 
-      rule(:call) { (single_call | chained_call).as(:call) | dictionnary }
-
-      root(:call)
+      def root
+        (
+          name.aka(:name) << (whitespace? << arguments.aka(:arguments)).maybe <<
+            (whitespace? << block.aka(:block)).maybe
+        ).aka(:call)
+      end
     end
   end
 end

data/lib/code/parser/chained_call.rb

@@ -0,0 +1,47 @@
+class Code
+  class Parser
+    class ChainedCall < Operation
+      def statement
+        ::Code::Parser::Dictionnary
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def dot
+        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
+      end
+    end
+  end
+end

data/lib/code/parser/class.rb

@@ -0,0 +1,45 @@
+class Code
+  class Parser
+    class Class < Language
+      def statement
+        ::Code::Parser::While
+      end
+
+      def name
+        ::Code::Parser::Name
+      end
+
+      def code
+        ::Code::Parser::Code
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def class_keyword
+        str("class")
+      end
+
+      def end_keyword
+        str("end")
+      end
+
+      def lesser
+        str("<")
+      end
+
+      def root
+        (
+          class_keyword << whitespace? << name.aka(:name) <<
+          (whitespace? << lesser << name.aka(:superclass)).maybe <<
+          code.aka(:body) << end_keyword.maybe
+        ).aka(:class) | statement
+      end
+    end
+  end
+end