language-ruby 0.5.0

data/lib/code/parser/operation.rb

@@ -0,0 +1,35 @@
+class Code
+  class Parser
+    class Operation < Language
+      def statement
+        raise NotImplementedError
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def operator
+        raise NotImplementedError
+      end
+
+      def root
+        (
+          statement.aka(:first) <<
+            (
+              whitespace? << operator.aka(:operator) << whitespace? <<
+                statement.aka(:statement)
+            ).repeat(1).aka(:others).maybe
+        )
+          .aka(:operation)
+          .then do |output|
+            output[:operation][:others] ? output : output[:operation][:first]
+          end
+      end
+    end
+  end
+end

data/lib/code/parser/or_keyword.rb

@@ -0,0 +1,21 @@
+class Code
+  class Parser
+    class OrKeyword < Operation
+      def statement
+        ::Code::Parser::NotKeyword
+      end
+
+      def or_keyword
+        str("or")
+      end
+
+      def and_keyword
+        str("and")
+      end
+
+      def operator
+        or_keyword | and_keyword
+      end
+    end
+  end
+end

data/lib/code/parser/or_operator.rb

@@ -0,0 +1,17 @@
+class Code
+  class Parser
+    class OrOperator < Operation
+      def statement
+        ::Code::Parser::AndOperator
+      end
+
+      def pipe
+        str("|")
+      end
+
+      def operator
+        pipe << pipe
+      end
+    end
+  end
+end

data/lib/code/parser/power.rb

@@ -0,0 +1,43 @@
+class Code
+  class Parser
+    class Power < Language
+      def power
+        ::Code::Parser::Power
+      end
+
+      def statement
+        ::Code::Parser::Negation
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def asterisk
+        str("*")
+      end
+
+      def operator
+        asterisk << asterisk
+      end
+
+      def root
+        (
+          statement.aka(:left) <<
+            (
+              whitespace? << operator.aka(:operator) << whitespace? <<
+                power.aka(:right)
+            ).maybe
+        )
+          .aka(:power)
+          .then do |output|
+            output[:power][:right] ? output : output[:power][:left]
+          end
+      end
+    end
+  end
+end

data/lib/code/parser/range.rb

@@ -0,0 +1,17 @@
+class Code
+  class Parser
+    class Range < Operation
+      def statement
+        ::Code::Parser::OrOperator
+      end
+
+      def dot
+        str(".")
+      end
+
+      def operator
+        (dot << dot << dot) | (dot << dot)
+      end
+    end
+  end
+end

data/lib/code/parser/rescue.rb

@@ -0,0 +1,39 @@
+class Code
+  class Parser
+    class Rescue < Language
+      def statement
+        ::Code::Parser::Ternary
+      end
+
+      def rescue_class
+        ::Code::Parser::Rescue
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def rescue_keyword
+        str("rescue")
+      end
+
+      def root
+        (
+          statement.aka(:left) <<
+            (
+              whitespace? << rescue_keyword << whitespace? <<
+                rescue_class.aka(:right)
+            ).maybe
+        )
+          .aka(:rescue)
+          .then do |output|
+            output[:rescue][:right] ? output : output[:rescue][:left]
+          end
+      end
+    end
+  end
+end

data/lib/code/parser/shift.rb

@@ -0,0 +1,21 @@
+class Code
+  class Parser
+    class Shift < Operation
+      def statement
+        ::Code::Parser::Addition
+      end
+
+      def greater
+        str(">")
+      end
+
+      def lesser
+        str("<")
+      end
+
+      def operator
+        (greater << greater) | (lesser << lesser)
+      end
+    end
+  end
+end

data/lib/code/parser/splat.rb

@@ -0,0 +1,31 @@
+class Code
+  class Parser
+    class Splat < Language
+      def statement
+        ::Code::Parser::Class
+      end
+
+      def splat
+        ::Code::Parser::Splat
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def ampersand
+        str("&")
+      end
+
+      def root
+        (ampersand.aka(:operator) << whitespace? << splat.aka(:right)).aka(
+          :splat
+        ) | statement
+      end
+    end
+  end
+end

data/lib/code/parser/statement.rb

@@ -0,0 +1,9 @@
+class Code
+  class Parser
+    class Statement < Language
+      def root
+        ::Code::Parser::Equality
+      end
+    end
+  end
+end

data/lib/code/parser/string.rb

@@ -0,0 +1,78 @@
+class Code
+  class Parser
+    class String < Language
+      def code
+        ::Code::Parser::Code
+      end
+
+      def name
+        ::Code::Parser::Name
+      end
+
+      def single_quote
+        str("'")
+      end
+
+      def double_quote
+        str('"')
+      end
+
+      def backslash
+        str("\\")
+      end
+
+      def opening_curly_bracket
+        str("{")
+      end
+
+      def closing_curly_bracket
+        str("}")
+      end
+
+      def colon
+        str(":")
+      end
+
+      def code_part
+        opening_curly_bracket << code << closing_curly_bracket.maybe
+      end
+
+      def single_quoted_text_part
+        (
+          backslash.ignore << opening_curly_bracket |
+            backslash.ignore << single_quote |
+            single_quote.absent << opening_curly_bracket.absent << any
+        ).repeat(1)
+      end
+
+      def double_quoted_text_part
+        (
+          backslash.ignore << opening_curly_bracket |
+            backslash.ignore << double_quote |
+            double_quote.absent << opening_curly_bracket.absent << any
+        ).repeat(1)
+      end
+
+      def single_quoted_string
+        single_quote.ignore <<
+          (code_part.aka(:code) | single_quoted_text_part.aka(:text)).repeat <<
+          single_quote.ignore.maybe
+      end
+
+      def double_quoted_string
+        double_quote.ignore <<
+          (code_part.aka(:code) | double_quoted_text_part.aka(:text)).repeat <<
+          double_quote.ignore.maybe
+      end
+
+      def symbol
+        (colon.ignore << name).aka(:text).repeat(1, 1)
+      end
+
+      def root
+        (single_quoted_string | double_quoted_string | symbol).aka(:string) |
+          ::Code::Parser::Number
+      end
+    end
+  end
+end

data/lib/code/parser/ternary.rb

@@ -0,0 +1,46 @@
+class Code
+  class Parser
+    class Ternary < Language
+      def statement
+        ::Code::Parser::Range
+      end
+
+      def ternary
+        ::Code::Parser::Ternary
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def question_mark
+        str("?")
+      end
+
+      def colon
+        str(":")
+      end
+
+      def root
+        (
+          statement.aka(:left) <<
+            (
+              whitespace? << question_mark << whitespace? <<
+                ternary.aka(:middle) <<
+                (
+                  whitespace? << colon << whitespace? << ternary.aka(:right)
+                ).maybe
+            ).maybe
+        )
+          .aka(:ternary)
+          .then do |output|
+            output[:ternary][:middle] ? output : output[:ternary][:left]
+          end
+      end
+    end
+  end
+end

data/lib/code/parser/unary_minus.rb

@@ -0,0 +1,31 @@
+class Code
+  class Parser
+    class UnaryMinus < Language
+      def unary_minus
+        ::Code::Parser::UnaryMinus
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def minus
+        str("-")
+      end
+
+      def operator
+        minus
+      end
+
+      def root
+        (operator.aka(:operator) << whitespace? << unary_minus.aka(:right)).aka(
+          :unary_minus
+        ) | ::Code::Parser::Power
+      end
+    end
+  end
+end

data/lib/code/parser/while.rb

@@ -0,0 +1,36 @@
+class Code
+  class Parser
+    class While < Language
+      def statement
+        ::Code::Parser::If
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def code
+        ::Code::Parser::Code
+      end
+
+      def while_keyword
+        str("while")
+      end
+
+      def until_keyword
+        str("until")
+      end
+
+      def end_keyword
+        str("end")
+      end
+
+      def root
+        (
+          (while_keyword | until_keyword).aka(:operator) << whitespace <<
+            statement.aka(:statement) << code.aka(:body) << end_keyword.maybe
+        ).aka(:while) | statement
+      end
+    end
+  end
+end

data/lib/code/parser/whitespace.rb

@@ -0,0 +1,49 @@
+class Code
+  class Parser
+    class Whitespace < Language
+      def space
+        str(" ")
+      end
+
+      def newline
+        str("\n")
+      end
+
+      def hashtag
+        str("#")
+      end
+
+      def slash
+        str("/")
+      end
+
+      def asterisk
+        str("*")
+      end
+
+      def hash_comment
+        hashtag << (newline.absent << any).repeat << newline.maybe
+      end
+
+      def double_slash_comment
+        slash << slash << (newline.absent << any).repeat << newline.maybe
+      end
+
+      def multi_line_comment
+        slash << asterisk << ((asterisk << slash).absent << any).repeat <<
+          asterisk.maybe << slash.maybe
+      end
+
+      def without_newline
+        (space | multi_line_comment).repeat(1)
+      end
+
+      def root
+        (
+          space | newline | hash_comment | double_slash_comment |
+            multi_line_comment
+        ).repeat(1)
+      end
+    end
+  end
+end

data/lib/code/parser.rb

@@ -0,0 +1,19 @@
+class Code
+  class Parser
+    def initialize(input)
+      @input = input
+    end
+
+    def self.parse(input)
+      new(input).parse
+    end
+
+    def parse
+      ::Code::Parser::Code.parse(input)
+    end
+
+    private
+
+    attr_reader :input
+  end
+end

data/lib/code/ruby.rb

@@ -0,0 +1,162 @@
+class Code
+  class Ruby
+    def initialize(raw = {})
+      @raw = raw
+    end
+
+    def self.to_code(raw)
+      new(raw).to_code
+    end
+
+    def self.from_code(raw)
+      new(raw).from_code
+    end
+
+    def to_code
+      if code?
+        raw
+      elsif true?
+        ::Code::Object::Boolean.new(raw)
+      elsif false?
+        ::Code::Object::Boolean.new(raw)
+      elsif string?
+        ::Code::Object::String.new(raw)
+      elsif symbol?
+        ::Code::Object::String.new(raw.to_s)
+      elsif integer?
+        ::Code::Object::Integer.new(raw)
+      elsif float?
+        ::Code::Object::Decimal.new(raw.to_s)
+      elsif big_decimal?
+        ::Code::Object::Decimal.new(raw)
+      elsif hash?
+        ::Code::Object::Dictionnary.new(
+          raw
+            .map do |key, value|
+              [::Code::Ruby.to_code(key), ::Code::Ruby.to_code(value)]
+            end
+            .to_h
+        )
+      elsif array?
+        ::Code::Object::List.new(
+          raw.map { |element| ::Code::Ruby.to_code(key) }
+        )
+      elsif proc?
+        ::Code::Object::RubyFunction.new(raw)
+      else
+        raise "Unsupported class #{raw.class} for Ruby to Code conversion"
+      end
+    end
+
+    def from_code
+      if code?
+        if code_boolean?
+          raw.raw
+        elsif code_decimal?
+          raw.raw
+        elsif code_integer?
+          raw.raw
+        elsif code_nothing?
+          raw.raw
+        elsif code_range?
+          raw.raw
+        elsif code_string?
+          raw.raw
+        elsif code_dictionnary?
+          raw
+            .raw
+            .map do |key, value|
+              [::Code::Ruby.to_code(key), ::Code::Ruby.to_code(value)]
+            end
+            .to_h
+        elsif code_list?
+          raw.raw.map { |element| ::Code::Ruby.to_code(element) }
+        else
+          raise "Unsupported class #{raw.class} for Code to Ruby conversion"
+        end
+      else
+        raw
+      end
+    end
+
+    private
+
+    attr_reader :raw
+
+    def code?
+      raw.is_a?(::Code::Object)
+    end
+
+    def true?
+      raw.is_a?(::TrueClass)
+    end
+
+    def false?
+      raw.is_a?(::FalseClass)
+    end
+
+    def hash?
+      raw.is_a?(::Hash)
+    end
+
+    def array?
+      raw.is_a?(::Array)
+    end
+
+    def string?
+      raw.is_a?(::String)
+    end
+
+    def symbol?
+      raw.is_a?(::Symbol)
+    end
+
+    def integer?
+      raw.is_a?(::Integer)
+    end
+
+    def float?
+      raw.is_a?(::Float)
+    end
+
+    def big_decimal?
+      raw.is_a?(::BigDecimal)
+    end
+
+    def proc?
+      raw.is_a?(::Proc)
+    end
+
+    def code_boolean?
+      raw.is_a?(::Code::Object::Boolean)
+    end
+
+    def code_decimal?
+      raw.is_a?(::Code::Object::Decimal)
+    end
+
+    def code_integer?
+      raw.is_a?(::Code::Object::Integer)
+    end
+
+    def code_nothing?
+      raw.is_a?(::Code::Object::Nothing)
+    end
+
+    def code_range?
+      raw.is_a?(::Code::Object::Range)
+    end
+
+    def code_string?
+      raw.is_a?(::Code::Object::String)
+    end
+
+    def code_dictionnary?
+      raw.is_a?(::Code::Object::Dictionnary)
+    end
+
+    def code_list?
+      raw.is_a?(::Code::Object::List)
+    end
+  end
+end

data/lib/code-ruby.rb

@@ -0,0 +1,10 @@
+require "bigdecimal"
+require "stringio"
+require "timeout"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore("#{__dir__}/template-ruby.rb")
+loader.ignore("#{__dir__}/code-ruby.rb")
+loader.ignore("#{__dir__}/language-ruby.rb")
+loader.setup