language-ruby 0.5.0

data/docs/stripe.code

@@ -0,0 +1,7 @@
+event = Stripe::Webhook.event
+
+if event.type == "payment_intent.succeeded"
+  payment_intent = event.data.object
+  amount = Money.format(payment_intent.amount, payment_intent.currency)
+  Sms.send("You got paid {amount}")
+end

data/docs/twitter.code

@@ -0,0 +1,9 @@
+twitter_username = fetch(:twitter_username) { "dorianmariefr" }
+
+Twitter
+  .search("to:{twitter_username}", type: :recent)
+  .each do |tweet|
+    next if Storage.exists?(tweet.id)
+    Storage.create!(tweet.id)
+    Sms.send("New mention: {tweet.user.screen_name}: {tweet.text}")
+  end

data/language-ruby.gemspec

@@ -0,0 +1,18 @@
+require_relative "lib/template/version"
+
+Gem::Specification.new do |s|
+  s.name = "language-ruby"
+  s.version = ::Template::Version
+  s.summary = "A Parsing Expression Grammar (PEG)"
+  s.description =
+    'A Parsing Expression Grammar (PEG) for making parsers'
+  s.authors = ["Dorian Marié"]
+  s.email = "dorian@dorianmarie.fr"
+  s.files = `git ls-files`.split($/)
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  s.homepage = "https://github.com/dorianmariefr/template-ruby"
+  s.license = "MIT"
+
+  s.add_dependency "zeitwerk", "~> 2"
+end

data/lib/code/error.rb

@@ -0,0 +1,18 @@
+class Code
+  class Error < StandardError
+    class TypeError < ::Code::Error
+    end
+
+    class Undefined < ::Code::Error
+    end
+
+    class UndefinedVariable < ::Code::Error
+    end
+
+    class ArgumentError < ::Code::Error
+    end
+
+    class IncompatibleContext < ::Code::Error
+    end
+  end
+end

data/lib/code/node/base_10.rb

@@ -0,0 +1,29 @@
+class Code
+  class Node
+    class Base10 < Node
+      def initialize(parsed)
+        @whole = parsed.delete(:whole)
+
+        if parsed.key?(:exponent)
+          @exponent = Node::Statement.new(parsed.delete(:exponent))
+        end
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        if @exponent
+          exponent = @exponent.evaluate(**args)
+
+          if exponent.is_a?(::Code::Object::Integer)
+            ::Code::Object::Integer.new(@whole.to_i, exponent: exponent)
+          else
+            ::Code::Object::Decimal.new(@whole, exponent: exponent)
+          end
+        else
+          ::Code::Object::Integer.new(@whole.to_i)
+        end
+      end
+    end
+  end
+end

data/lib/code/node/base_16.rb

@@ -0,0 +1,13 @@
+class Code
+  class Node
+    class Base16 < Node
+      def initialize(parsed)
+        @base_16 = parsed
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Integer.new(@base_16.to_i(16))
+      end
+    end
+  end
+end

data/lib/code/node/base_2.rb

@@ -0,0 +1,13 @@
+class Code
+  class Node
+    class Base2 < Node
+      def initialize(parsed)
+        @base_2 = parsed
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Integer.new(@base_2.to_i(2))
+      end
+    end
+  end
+end

data/lib/code/node/base_8.rb

@@ -0,0 +1,13 @@
+class Code
+  class Node
+    class Base8 < Node
+      def initialize(parsed)
+        @base_8 = parsed
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Integer.new(@base_8.to_i(8))
+      end
+    end
+  end
+end

data/lib/code/node/boolean.rb

@@ -0,0 +1,22 @@
+class Code
+  class Node
+    class Boolean < Node
+      TRUE_KEYWORD = "true"
+      FALSE_KEYWORD = "false"
+
+      def initialize(parsed)
+        @boolean = parsed
+      end
+
+      def evaluate(**args)
+        if @boolean == TRUE_KEYWORD
+          ::Code::Object::Boolean.new(true)
+        elsif @boolean == FALSE_KEYWORD
+          ::Code::Object::Boolean.new(false)
+        else
+          raise NotImplementedError.new(@boolean)
+        end
+      end
+    end
+  end
+end

data/lib/code/node/call.rb

@@ -0,0 +1,47 @@
+class Code
+  class Node
+    class Call < Node
+      class Block < Node
+        def initialize(parsed)
+          @parameters =
+            parsed
+              .delete(:parameters) { [] }
+              .map { |parameter| Node::FunctionParameter.new(parameter) }
+
+          @body = Node::Code.new(parsed.delete(:body))
+
+          super(parsed)
+        end
+
+        def evaluate(**args)
+          ::Code::Object::Argument.new(
+            ::Code::Object::Function.new(parameters: @parameters, body: @body)
+          )
+        end
+      end
+
+      def initialize(parsed)
+        @name = parsed.delete(:name)
+        @arguments =
+          parsed
+            .delete(:arguments) { [] }
+            .map { |argument| Node::CallArgument.new(argument) }
+
+        if parsed.key?(:block)
+          @block = Node::Call::Block.new(parsed.delete(:block))
+        end
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        arguments = @arguments.map { |argument| argument.evaluate(**args) }
+        arguments << @block.evaluate(**args) if @block
+
+        name = ::Code::Object::String.new(@name)
+
+        args.fetch(:object).call(operator: name, arguments: arguments, **args)
+      end
+    end
+  end
+end

data/lib/code/node/call_argument.rb

@@ -0,0 +1,21 @@
+class Code
+  class Node
+    class CallArgument < Node
+      def initialize(parsed)
+        @value = Node::Code.new(parsed.delete(:value))
+        @name = parsed.delete(:name)
+      end
+
+      def evaluate(**args)
+        if @name
+          ::Code::Object::Argument.new(
+            @value.evaluate(**args),
+            name: ::Code::Object::String.new(@name)
+          )
+        else
+          ::Code::Object::Argument.new(@value.evaluate(**args))
+        end
+      end
+    end
+  end
+end

data/lib/code/node/chained_call.rb

@@ -0,0 +1,23 @@
+class Code
+  class Node
+    class ChainedCall < Node
+      def initialize(parsed)
+        @first = Node::Statement.new(parsed.delete(:first))
+        @others =
+          parsed
+            .delete(:others)
+            .map { |operator| Node::Statement.new(operator) }
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        first = @first.evaluate(**args)
+
+        @others.reduce(first) do |acc, element|
+          element.evaluate(**args.merge(object: acc))
+        end
+      end
+    end
+  end
+end

data/lib/code/node/code.rb

@@ -0,0 +1,20 @@
+class Code
+  class Node
+    class Code < Node
+      def initialize(parsed)
+        @statements = parsed.map { |statement| Node::Statement.new(statement) }
+      end
+
+      def evaluate(**args)
+        last = ::Code::Object::Nothing.new
+
+        @statements.each do |statement|
+          last =
+            statement.evaluate(**args.merge(object: ::Code::Object::Global.new))
+        end
+
+        last
+      end
+    end
+  end
+end

data/lib/code/node/decimal.rb

@@ -0,0 +1,26 @@
+class Code
+  class Node
+    class Decimal < Node
+      def initialize(parsed)
+        @decimal = parsed.delete(:decimal)
+
+        if parsed.key?(:exponent)
+          @exponent = Node::Statement.new(parsed.delete(:exponent))
+        end
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        if @exponent
+          ::Code::Object::Decimal.new(
+            @decimal,
+            exponent: @exponent.evaluate(**args)
+          )
+        else
+          ::Code::Object::Decimal.new(@decimal)
+        end
+      end
+    end
+  end
+end

data/lib/code/node/dictionnary.rb

@@ -0,0 +1,33 @@
+class Code
+  class Node
+    class Dictionnary < Node
+      class KeyValue < Node
+        def initialize(parsed)
+          if parsed.key?(:statement)
+            @key = Node::Statement.new(parsed.delete(:statement))
+          elsif parsed.key?(:name)
+            @key = Node::String.new([{ text: parsed.delete(:name) }])
+          end
+
+          @value = Node::Code.new(parsed.delete(:value))
+        end
+
+        def evaluate(**args)
+          [@key.evaluate(**args), @value.evaluate(**args)]
+        end
+      end
+
+      def initialize(parsed)
+        parsed = [] if parsed == ""
+        @key_values =
+          parsed.map { |key_value| Node::Dictionnary::KeyValue.new(key_value) }
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Dictionnary.new(
+          @key_values.map { |key_value| key_value.evaluate(**args) }.to_h
+        )
+      end
+    end
+  end
+end

data/lib/code/node/equal.rb

@@ -0,0 +1,34 @@
+class Code
+  class Node
+    class Equal < Node
+      def initialize(parsed)
+        @operator = parsed.delete(:operator)
+        @left = parsed.delete(:left)
+        @right = Node::Statement.new(parsed.delete(:right))
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        right = @right.evaluate(**args)
+        left = ::Code::Object::String.new(@left)
+        context = args.fetch(:context)
+
+        if @operator == ""
+          context[left] = right
+        else
+          if context[left].nil?
+            raise ::Code::Error::Undefined.new("#{left} is not defined")
+          end
+
+          context[left] = context.fetch(left).call(
+            operator: @operator,
+            arguments: [::Code::Object::Argument.new(right)],
+            **args
+          )
+        end
+
+        args[:context][left]
+      end
+    end
+  end
+end

data/lib/code/node/function.rb

@@ -0,0 +1,20 @@
+class Code
+  class Node
+    class Function < Node
+      def initialize(parsed)
+        @parameters =
+          parsed
+            .delete(:parameters) { [] }
+            .map { |parameter| Node::FunctionParameter.new(parameter) }
+
+        @body = Node::Code.new(parsed.delete(:body))
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Function.new(parameters: @parameters, body: @body)
+      end
+    end
+  end
+end

data/lib/code/node/function_parameter.rb

@@ -0,0 +1,31 @@
+class Code
+  class Node
+    class FunctionParameter < Node
+      def initialize(parsed)
+        @name = parsed.delete(:name)
+        @keyword = !!parsed.delete(:keyword)
+        super(parsed)
+      end
+
+      def name
+        ::Code::Object::String.new(@name)
+      end
+
+      def regular?
+        !@keyword
+      end
+
+      def keyword?
+        !!@keyword
+      end
+
+      def regular_splat?
+        false
+      end
+
+      def keyword_splat?
+        false
+      end
+    end
+  end
+end

data/lib/code/node/if.rb

@@ -0,0 +1,59 @@
+class Code
+  class Node
+    class If < Node
+      IF_KEYWORD = "if"
+      UNLESS_KEYWORD = "unless"
+      ELSIF_KEYWORD = "elsif"
+      ELSE_KEYWORD = "else"
+
+      class Else < Node
+        attr_reader :operator, :statement, :body
+
+        def initialize(parsed)
+          @operator = parsed.delete(:operator)
+          @body = Node::Code.new(parsed.delete(:body))
+
+          if parsed.key?(:statement)
+            @statement = Node::Statement.new(parsed.delete(:statement))
+          end
+        end
+      end
+
+      def initialize(parsed)
+        @first_operator = parsed.delete(:first_operator)
+        @first_statement = Node::Statement.new(parsed.delete(:first_statement))
+        @first_body = Node::Code.new(parsed.delete(:first_body))
+        @elses =
+          parsed.delete(:elses) { [] }.map { |elses| Node::If::Else.new(elses) }
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        if @first_operator == IF_KEYWORD &&
+             @first_statement.evaluate(**args).truthy?
+          @first_body.evaluate(**args)
+        elsif @first_operator == UNLESS_KEYWORD &&
+              @first_statement.evaluate(**args).falsy?
+          @first_body.evaluate(**args)
+        else
+          @elses.each do |elses|
+            if elses.operator == ELSIF_KEYWORD &&
+                 elses.statement.evaluate(**args).truthy?
+              return elses.body.evaluate(**args)
+            elsif elses.operator == IF_KEYWORD &&
+                  elses.statement.evaluate(**args).truthy?
+              return elses.body.evaluate(**args)
+            elsif elses.operator == UNLESS_KEYWORD &&
+                  elses.statement.evaluate(**args).falsy?
+              return elses.body.evaluate(**args)
+            elsif elses.operator == ELSE_KEYWORD
+              return elses.body.evaluate(**args)
+            end
+          end
+
+          ::Code::Object::Nothing.new
+        end
+      end
+    end
+  end
+end

data/lib/code/node/if_modifier.rb

@@ -0,0 +1,47 @@
+class Code
+  class Node
+    class IfModifier < Node
+      IF_KEYWORD = "if"
+      UNLESS_KEYWORD = "unless"
+      WHILE_KEYWORD = "while"
+      UNTIL_KEYWORD = "until"
+
+      def initialize(parsed)
+        @operator = parsed.delete(:operator)
+        @left = Node::Statement.new(parsed.delete(:left))
+        @right = Node::Statement.new(parsed.delete(:right))
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        if @operator == IF_KEYWORD
+          if @right.evaluate(**args).truthy?
+            @left.evaluate(**args)
+          else
+            ::Code::Object::Nothing.new
+          end
+        elsif @operator == UNLESS_KEYWORD
+          if @right.evaluate(**args).falsy?
+            @left.evaluate(**args)
+          else
+            ::Code::Object::Nothing.new
+          end
+        elsif @operator == WHILE_KEYWORD
+          last = ::Code::Object::Nothing.new
+
+          last = @left.evaluate(**args) while @right.evaluate(**args).truthy?
+
+          last
+        elsif @operator == UNTIL_KEYWORD
+          last = ::Code::Object::Nothing.new
+
+          last = @left.evaluate(**args) while @right.evaluate(**args).falsy?
+
+          last
+        else
+          raise NotImplementedError.new(@operator)
+        end
+      end
+    end
+  end
+end

data/lib/code/node/list.rb

@@ -0,0 +1,16 @@
+class Code
+  class Node
+    class List < Node
+      def initialize(parsed)
+        parsed = [] if parsed == ""
+        @elements = parsed.map { |element| Node::Code.new(element) }
+      end
+
+      def evaluate(**args)
+        ::Code::Object::List.new(
+          @elements.map { |element| element.evaluate(**args) }
+        )
+      end
+    end
+  end
+end

data/lib/code/node/negation.rb

@@ -0,0 +1,15 @@
+class Code
+  class Node
+    class Negation < Node
+      def initialize(parsed)
+        @operator = parsed.delete(:operator)
+        @right = Node::Statement.new(parsed.delete(:right))
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
+      end
+    end
+  end
+end

data/lib/code/node/not.rb

@@ -0,0 +1,15 @@
+class Code
+  class Node
+    class Not < Node
+      def initialize(parsed)
+        @operator = parsed.delete(:operator)
+        @right = Node::Statement.new(parsed.delete(:right))
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
+      end
+    end
+  end
+end

data/lib/code/node/nothing.rb

@@ -0,0 +1,12 @@
+class Code
+  class Node
+    class Nothing < Node
+      def initialize(parsed)
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Nothing.new
+      end
+    end
+  end
+end

data/lib/code/node/number.rb

@@ -0,0 +1,25 @@
+class Code
+  class Node
+    class Number < Node
+      def initialize(parsed)
+        if parsed.key?(:decimal)
+          @statement = Node::Decimal.new(parsed.delete(:decimal))
+        elsif parsed.key?(:base_16)
+          @statement = Node::Base16.new(parsed.delete(:base_16))
+        elsif parsed.key?(:base_10)
+          @statement = Node::Base10.new(parsed.delete(:base_10))
+        elsif parsed.key?(:base_8)
+          @statement = Node::Base8.new(parsed.delete(:base_8))
+        elsif parsed.key?(:base_2)
+          @statement = Node::Base2.new(parsed.delete(:base_2))
+        end
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        @statement.evaluate(**args)
+      end
+    end
+  end
+end

data/lib/code/node/operation.rb

@@ -0,0 +1,38 @@
+class Code
+  class Node
+    class Operation < Node
+      class Operator < Node
+        attr_reader :operator, :statement
+
+        def initialize(parsed)
+          @operator = parsed.delete(:operator)
+          @statement = Node::Statement.new(parsed.delete(:statement))
+        end
+      end
+
+      def initialize(parsed)
+        @first = Node::Statement.new(parsed.delete(:first))
+        @others =
+          parsed
+            .delete(:others)
+            .map { |operator| Node::Operation::Operator.new(operator) }
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        first = @first.evaluate(**args)
+
+        @others.reduce(first) do |left, right|
+          statement = right.statement.evaluate(**args)
+
+          left.call(
+            operator: right.operator,
+            arguments: [::Code::Object::Argument.new(statement)],
+            **args
+          )
+        end
+      end
+    end
+  end
+end

data/lib/code/node/power.rb

@@ -0,0 +1,20 @@
+class Code
+  class Node
+    class Power < Node
+      def initialize(parsed)
+        @operator = parsed.delete(:operator)
+        @left = Node::Statement.new(parsed.delete(:left))
+        @right = Node::Statement.new(parsed.delete(:right))
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        @left.evaluate(**args).call(
+          operator: @operator,
+          arguments: [::Code::Object::Argument.new(@right.evaluate(**args))],
+          **args
+        )
+      end
+    end
+  end
+end