language-ruby 0.5.0

data/lib/code/object.rb

@@ -0,0 +1,197 @@
+class Code
+  class Object
+    include Comparable
+
+    def call(**args)
+      operator = args.fetch(:operator, nil)
+      arguments = args.fetch(: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 == "<=>"
+        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
+    end
+
+    def truthy?
+      true
+    end
+
+    def falsy?
+      !truthy?
+    end
+
+    def <=>(other)
+      if respond_to?(:raw)
+        other.respond_to?(:raw) ? raw <=> other.raw : raw <=> other
+      else
+        other <=> self
+      end
+    end
+
+    def ==(other)
+      if respond_to?(:raw)
+        other.respond_to?(:raw) ? raw == other.raw : raw == other
+      else
+        other == self
+      end
+    end
+    alias_method :eql?, :==
+
+    def hash
+      if respond_to?(:raw)
+        [self.class, raw].hash
+      else
+        raise NotImplementedError.new(self.class.name)
+      end
+    end
+
+    def to_s
+      raise NotImplementedError.new(self.class.name)
+    end
+
+    private
+
+    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"
+          )
+        )
+      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
+    end
+
+    def equal(other)
+      ::Code::Object::Boolean.new(self == other)
+    end
+
+    def strict_equal(other)
+      ::Code::Object::Boolean.new(self === other)
+    end
+
+    def different(other)
+      ::Code::Object::Boolean.new(self != other)
+    end
+
+    def compare(other)
+      ::Code::Object::Integer.new(self <=> other)
+    end
+
+    def and_operator(other)
+      truthy? ? other : self
+    end
+
+    def or_operator(other)
+      truthy? ? self : other
+    end
+
+    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

@@ -0,0 +1,21 @@
+class Code
+  class Parser
+    class Addition < Operation
+      def statement
+        ::Code::Parser::Multiplication
+      end
+
+      def plus
+        str("+")
+      end
+
+      def minus
+        str("-")
+      end
+
+      def operator
+        plus | minus
+      end
+    end
+  end
+end

data/lib/code/parser/and_operator.rb

@@ -0,0 +1,17 @@
+class Code
+  class Parser
+    class AndOperator < Operation
+      def statement
+        ::Code::Parser::EqualityLower
+      end
+
+      def ampersand
+        str("&")
+      end
+
+      def operator
+        ampersand << ampersand
+      end
+    end
+  end
+end

data/lib/code/parser/bitwise_and.rb

@@ -0,0 +1,17 @@
+class Code
+  class Parser
+    class BitwiseAnd < Operation
+      def statement
+        ::Code::Parser::Shift
+      end
+
+      def ampersand
+        str("&")
+      end
+
+      def operator
+        ampersand
+      end
+    end
+  end
+end

data/lib/code/parser/bitwise_or.rb

@@ -0,0 +1,21 @@
+class Code
+  class Parser
+    class BitwiseOr < Operation
+      def statement
+        ::Code::Parser::BitwiseAnd
+      end
+
+      def pipe
+        str("|")
+      end
+
+      def caret
+        str("^")
+      end
+
+      def operator
+        pipe | caret
+      end
+    end
+  end
+end

data/lib/code/parser/boolean.rb

@@ -0,0 +1,17 @@
+class Code
+  class Parser
+    class Boolean < Language
+      def true_keyword
+        str("true")
+      end
+
+      def false_keyword
+        str("false")
+      end
+
+      def root
+        (true_keyword | false_keyword).aka(:boolean) | ::Code::Parser::Nothing
+      end
+    end
+  end
+end

data/lib/code/parser/call.rb

@@ -0,0 +1,122 @@
+class Code
+  class Parser
+    class Call < Language
+      def name
+        ::Code::Parser::Name
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def code
+        ::Code::Parser::Code
+      end
+
+      def code_present
+        ::Code::Parser::Code.new.present
+      end
+
+      def colon
+        str(":")
+      end
+
+      def comma
+        str(",")
+      end
+
+      def pipe
+        str("|")
+      end
+
+      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
+
+      def parameter
+        keyword_parameter | regular_parameter
+      end
+
+      def parameters
+        pipe.ignore << whitespace? << parameter.repeat(0, 1) <<
+          (whitespace? << comma << whitespace? << parameter).repeat <<
+          whitespace? << pipe.ignore.maybe
+      end
+
+      def block
+        (
+          do_keyword << whitespace? << parameters.aka(:parameters).maybe <<
+            code.aka(:body) << end_keyword.maybe
+        ) |
+          (
+            opening_curly_bracket << whitespace? <<
+              parameters.aka(:parameters).maybe << code.aka(:body) <<
+              closing_curly_bracket.maybe
+          )
+      end
+
+      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

data/lib/code/parser/code.rb

@@ -0,0 +1,25 @@
+class Code
+  class Parser
+    class Code < Language
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?(&block)
+        whitespace.maybe(&block)
+      end
+
+      def statement
+        ::Code::Parser::Statement
+      end
+
+      def present
+        (whitespace? << statement << whitespace?).repeat(1)
+      end
+
+      def root
+        present | whitespace?.then { [] }
+      end
+    end
+  end
+end

data/lib/code/parser/dictionnary.rb

@@ -0,0 +1,67 @@
+class Code
+  class Parser
+    class Dictionnary < Language
+      def code
+        ::Code::Parser::Code.new.present
+      end
+
+      def statement
+        ::Code::Parser::Statement
+      end
+
+      def name
+        ::Code::Parser::Name
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def opening_curly_bracket
+        str("{")
+      end
+
+      def closing_curly_bracket
+        str("}")
+      end
+
+      def comma
+        str(",")
+      end
+
+      def colon
+        str(":")
+      end
+
+      def equal
+        str("=")
+      end
+
+      def greater
+        str(">")
+      end
+
+      def key_value
+        (name.aka(:name) << colon << code.aka(:value)) |
+          (statement.aka(:statement) << colon << code.aka(:value)) |
+          (
+            statement.aka(:statement) << whitespace? << equal << greater <<
+              code.aka(:value)
+          )
+      end
+
+      def root
+        (
+          opening_curly_bracket.ignore << whitespace? <<
+            key_value.repeat(0, 1) <<
+            (whitespace? << comma << whitespace? << key_value).repeat <<
+            (whitespace? << closing_curly_bracket.ignore).maybe
+        ).aka(:dictionnary) | ::Code::Parser::List
+      end
+    end
+  end
+end

data/lib/code/parser/equal.rb

@@ -0,0 +1,94 @@
+class Code
+  class Parser
+    class Equal < Language
+      def statement
+        ::Code::Parser::Rescue
+      end
+
+      def name
+        ::Code::Parser::Name
+      end
+
+      def equal_class
+        ::Code::Parser::Equal
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def equal
+        str("=")
+      end
+
+      def plus
+        str("+")
+      end
+
+      def minus
+        str("-")
+      end
+
+      def asterisk
+        str("*")
+      end
+
+      def slash
+        str("/")
+      end
+
+      def percent
+        str("%")
+      end
+
+      def greater
+        str(">")
+      end
+
+      def lesser
+        str("<")
+      end
+
+      def ampersand
+        str("&")
+      end
+
+      def pipe
+        str("|")
+      end
+
+      def caret
+        str("^")
+      end
+
+      def dot
+        str(".")
+      end
+
+      def operator
+        equal.ignore | (plus << equal.ignore) | (minus << equal.ignore) |
+          (asterisk << equal.ignore) | (slash << equal.ignore) |
+          (percent << equal.ignore) | (greater << greater << equal.ignore) |
+          (lesser << lesser << equal.ignore) | (ampersand << equal.ignore) |
+          (pipe << equal.ignore) | (caret << equal.ignore) |
+          (pipe << pipe << equal.ignore) |
+          (ampersand << ampersand << equal.ignore)
+      end
+
+      def names
+        name << (dot << name).repeat
+      end
+
+      def root
+        (
+          names.aka(:left) << whitespace? << operator.aka(:operator) <<
+            whitespace? << equal_class.aka(:right)
+        ).aka(:equal) | statement
+      end
+    end
+  end
+end