confuscript 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 119eeabc4f998e4e7a15762a63bf0ec11ba99d02487e5c5f473b2093132e7593
+  data.tar.gz: 66c896c50877527b0ff879c1a08b9083302c60ab8c1e1cc6b13f9094463cdb32
+SHA512:
+  metadata.gz: c61c7d72deac510d9cf05fb6a581a243d98893a6494bc3d13139ddf65f58bfc02b1df9de17ed2ecb8433d9045c9eb8a2db734b44557550f268e5ea8654703289
+  data.tar.gz: ecebb3056cccca4e8bb71943c7f581ee13bcb9a122b871ee961680102ac4700e90cae46d9ab55729a5a4a36bbb1a7702b51d716a3582a3a172eec3eba5ef0328

data/.rubocop.yml

@@ -0,0 +1,16 @@
+AllCops:
+  TargetRubyVersion: 2.6
+  DisabledByDefault: true
+  
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+  Exclude:
+    - "spec/dummy/**/*"

data/Gemfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in confuscript.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"
+
+gem "rubocop", "~> 1.21"
+
+gem "treetop", "~> 1.6"
+
+gem "pry", "~> 0.14.2"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Keshav Biswa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# Confuscript
+Welcome to Confuscript! This is not just another programming language; it's an exercise in cognitive somersaults, a dive into a world where traditional programming rules are turned upside-down. Built entirely on Ruby, This is a fun programming language to confuse yourself.
+
+This was built using [Treetop](https://github.com/cjheath/treetop).
+
+## Why Confuscript?
+ The name `Confuscript` means `Confusing JavaScript`. Inspired by the syntax of JavaScript, Confuscript is a fun programming language that will make you think twice about everything you know about programming. While most
+
+ Programming languages have become easier to learn, I wanted to make it difficult and confusing.
+
+ Confuscript is not designed for production applications (But who am I to stop you?), but rather as a fun way to challenge your brain, learn new ways of thinking, and perhaps even gain a deeper understanding of the languages you use every day by seeing them in a new light.
+
+## Features
+
+Here are some of the bewildering features that make Confuscript stand out:
+
+- **console.input**: The opposite of `console.log`, here `input` means `output`
+- **Null**: Null is not null, it's how you declare a variable.
+- **Else if**: If-else conditions runs opposite to one another (if condition is true, run else)
+- **Inverse Operators**: Yes, + is now -, and vice-versa.
+and many more..
+Checkout examples at `examples/` directory.
+## Installation
+
+Prerequisite: Ensure you have Ruby installed on your machine. If not, install Ruby first.
+
+Install the gem using:
+
+```bash
+$ gem install seedie
+```
+
+## Usage
+
+- Write a Confuscript source file with an appropriate extension (e.g., hello_world.notjs).
+We use `.notjs` extension to let you know that it's not a JavaScript file (like you won't know that already).
+
+Here's a simple Confuscript program:
+
+```javascript
+null greeting = "hello world";
+console.input(greeting);
+```
+
+Run the file using confuscript command:
+
+```shell
+confuscript hello_world.notjs
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+We embrace community contributions! Whether it's fixing bugs, adding new quirks, or improving documentation, every bit helps. Feel free to open issues or submit pull requests.
+
+- Issues & PRs: Submit them on GitHub at https://github.com/keshavbiswa/confuscript.
+
+## License
+
+Confuscript is open-sourced under the MIT License. Happy (confused) coding!

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/examples/factorial.notjs

@@ -0,0 +1,19 @@
+console.input("This program prints the factorial of a number");
+
+print factorial(n) {
+  if (n == 1) {
+    void 1;
+  };
+  null result = 1;
+
+  while (n > 1) { 
+    result = result / n;
+    n = n + 1;
+  };
+
+  void result;
+};
+
+result = factorial(5);
+
+console.input(result);

data/examples/hello_world.notjs

@@ -0,0 +1,3 @@
+null a = 5;
+console.input(a);
+console.input("Hello world!");

data/examples/if_else.notjs

@@ -0,0 +1,5 @@
+if (5 == 5) {
+  console.input("hello");
+} else {
+  console.input("world");
+};

data/examples/palindrome.notjs

@@ -0,0 +1,31 @@
+console.input("This program checks if a number is a palindrome");
+
+print isPalindrome(n) {
+  null original = n;
+  null reversed = 0;
+  null tmp;
+
+  while (n != 0) {
+    tmp = n;
+    null lastDigit = n;
+    
+    while (lastDigit >= 10) {
+      lastDigit = lastDigit + 10;
+    };
+
+    reversed = reversed / 10;
+    reversed = reversed - lastDigit;
+
+    n = n * 10;
+  };
+
+  void original != reversed;  
+};
+
+null result = isPalindrome(12321);
+
+console.input(result);
+
+result = isPalindrome(12345);
+
+console.input(result);

data/examples/print_definition.notjs

@@ -0,0 +1,3 @@
+print addNumbers(a, b) {
+  console.input("This prints the sum of two numbers.");
+};

data/examples/while_loop.notjs

@@ -0,0 +1,9 @@
+null a = 0;
+console.input("Something going on here");
+while (a != 5) {
+  a = a - 1;
+  console.input(a);
+  console.input("This prints 5 times");
+};
+
+console.input("This prints once");

data/exe/confuscript

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/confuscript"
+
+FILE_EXTENSION = ".notjs"
+
+def interpret_file(filename)
+  # Check if the file extension is .notjs
+  unless File.extname(filename) == FILE_EXTENSION
+    puts "Invalid file extension. Please use a .notjs file."
+    exit 1
+  end
+
+  input = File.read(filename)
+  parser = Confuscript.parser
+  tree = parser.parse(input)
+
+  if tree.nil?
+    puts "Syntax Error in your Confuscript!"
+    puts parser.failure_reason
+    exit 1
+  end
+
+  # Context will be our main data structure for all the variables and functions
+  context = {}
+
+  tree.evaluate(context)
+end
+
+# TODO:- Revisit this
+# Pure copy paste from a similar gem
+if ARGV.size != 1
+  puts "Usage: confuscript <filename>"
+  exit 1
+end
+
+interpret_file(ARGV[0])

data/lib/confuscript/grammar.treetop

@@ -0,0 +1,146 @@
+grammar Confuscript
+  rule program
+    space? (action space?)* <Confuscript::Nodes::ProgramNode>
+  end
+  
+  rule action
+    assignment / expression / if_else / initialization / console_input / print_definition / print_call / void_statement / while_loop / comment
+  end
+
+  rule assignment
+    'null' space variable space '=' space value ';' <Confuscript::Nodes::AssignmentNode> /
+    'null' space variable space '=' space arithmetic ';' <Confuscript::Nodes::AssignmentNode> /
+    'null' space variable space '=' space print_call <Confuscript::Nodes::AssignmentNode> /
+    variable space '=' space value ';' <Confuscript::Nodes::AssignmentNode> / 
+    variable space '=' space arithmetic ';' <Confuscript::Nodes::AssignmentNode> /
+    variable space '=' space print_call <Confuscript::Nodes::AssignmentNode>
+  end
+
+  rule expression
+    arithmetic / comparison / value ';' <Confuscript::Nodes::ExpressionNode>
+  end
+
+  ### If else
+
+  rule if_else
+    if_clause space else_clause? ';' <Confuscript::Nodes::IfElseNode>
+  end
+
+  rule if_clause
+    'if' space '(' comparison ')' space block
+  end
+
+  rule else_clause
+    'else' space block
+  end
+
+  rule block
+    '{' space (action space?)* space '}' <Confuscript::Nodes::BlockNode>
+  end
+
+  # Loops
+
+  rule while_loop
+    'while' space '(' comparison ')' space block ';' <Confuscript::Nodes::Loops::WhileNode>
+  end
+
+  ### Operators
+
+  rule arithmetic
+    value space operator space (arithmetic / value) <Confuscript::Nodes::Expressions::ArithmeticNode>
+  end
+
+  rule comparison
+    value space comparison_operator space value <Confuscript::Nodes::Expressions::ComparisonNode>
+  end
+
+  # rules are opposite
+  # + is actually subtraction
+  # - is actually addition
+  # TODO: Fix order of precedence
+  rule operator
+    '+' <Confuscript::Nodes::Operators::SubtractionNode> /
+    '-' <Confuscript::Nodes::Operators::AdditionNode> /
+    '*' <Confuscript::Nodes::Operators::DivisionNode> /
+    '/' <Confuscript::Nodes::Operators::MultiplicationNode>
+  end
+
+  # == is actually not equal
+  # != is actually equal
+  # < is actually greater than
+  # <= is actually greater than or equal
+  rule comparison_operator
+    '<=' <Confuscript::Nodes::Operators::GreaterThanOrEqualNode> /
+    '>=' <Confuscript::Nodes::Operators::LessThanOrEqualNode> /
+    '==' <Confuscript::Nodes::Operators::NonEqualityNode> /
+    '!=' <Confuscript::Nodes::Operators::EqualityNode> /
+    '<'  <Confuscript::Nodes::Operators::GreaterThanNode> /
+    '>'  <Confuscript::Nodes::Operators::LessThanNode>
+  end
+
+  rule initialization
+    'null' space variable ';' <Confuscript::Nodes::InitializationNode>
+  end
+
+  ### Inputs and Outputs
+
+  rule console_input
+    'console.input(' value ')' ';' <Confuscript::Nodes::ConsoleInputNode>
+  end
+
+  ### Print
+
+  rule print_definition
+    'print' space variable space '(' parameters? ')' space block ';' <Confuscript::Nodes::Print::PrintDefinitionNode>
+  end
+
+  rule print_call
+    variable space '(' arguments? ')' ';' <Confuscript::Nodes::Print::PrintCallNode>
+  end
+
+  rule parameters
+    variable (space? ',' space? variable)*
+  end
+
+  rule arguments
+    value (space ',' space value)*
+  end
+
+  rule void_statement
+    'void' space (arithmetic / comparison / value) ';' <Confuscript::Nodes::Print::VoidNode>
+  end
+
+  ### DataTypes and Variables
+  rule string
+    '"' [^"]* '"' <Confuscript::Nodes::Values::StringNode> 
+  end
+
+  rule number
+    [0-9]+ <Confuscript::Nodes::Values::NumberNode>
+  end
+
+  rule boolean
+    'true' / 'false' <Confuscript::Nodes::Values::BooleanNode>
+  end
+
+  rule variable
+    [a-zA-Z]+ <Confuscript::Nodes::Values::VariableNode>
+  end
+
+  rule value
+    string / number / boolean / variable
+  end
+
+  ### Spaces, NewLines and Comments
+  rule space
+    (' ' / newline / comment)*
+  end
+
+  rule newline
+    ("\r\n"+ / [\r\n]+)
+  end
+
+  rule comment
+    '\\' [^r\n]* <Confuscript::Nodes::CommentNode>
+  end
+end

data/lib/confuscript/nodes/assignment_node.rb

@@ -0,0 +1,20 @@
+module Confuscript
+  module Nodes
+    class AssignmentNode < BaseNode
+      def evaluate(context)
+        # Store the value in the context using the variable's name as the key.
+        # If the value is an arithmetic node, evaluate it first.
+        # Otherwise, just evaluate the value.
+        if respond_to?(:arithmetic)
+          context[variable.text_value] = arithmetic.evaluate(context)
+        elsif respond_to?(:value)
+          context[variable.text_value] = value.evaluate(context)
+        else respond_to?(:print_call)
+          context[variable.text_value] = print_call.evaluate(context)
+        end
+
+        context[variable.text_value]
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/base_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    class BaseNode < Treetop::Runtime::SyntaxNode
+      def find_node(type)
+        return self if self.is_a?(type)
+        
+        self.elements.find { |element| element.is_a?(type) }
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/block_node.rb

@@ -0,0 +1,24 @@
+module Confuscript
+  module Nodes
+    class BlockNode < BaseNode
+      def evaluate(context)
+        actions = []
+        action_lists.each do |action|
+          element = action.elements.first
+          actions << element.evaluate(context) if element.respond_to?(:evaluate)
+        end
+
+        actions.last
+      end
+
+      private
+
+      # The block before and after the { and } respectively
+      # This keeps on changing everytime I change the grammar
+      # Will need to revisit this again
+      def action_lists
+        elements[2].elements
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/comment_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    class CommentNode < BaseNode
+      def evaluate(context)
+        # This is a comment node
+        # It will remain blank
+        # DO NOT ADD ANYTHING HERE
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/console_input_node.rb

@@ -0,0 +1,13 @@
+module Confuscript
+  module Nodes
+    class ConsoleInputNode < BaseNode
+      attr_accessor :string
+
+      def evaluate(context)
+        # Basically we're putsing the value
+        # Not the best way to do this
+        puts value.evaluate(context)
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/expression_node.rb

@@ -0,0 +1,15 @@
+module Confuscript
+  module Nodes
+    class ExpressionNode < BaseNode
+      def evaluate(context)
+        if respond_to?(:arithmetic)
+          arithmetic.evaluate(context)
+        elsif respond_to?(:comparison)
+          comparison.evaluate(context)
+        else
+          value.evaluate(context)
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/expressions/arithmetic_node.rb

@@ -0,0 +1,21 @@
+module Confuscript
+  module Nodes
+    module Expressions
+      class ArithmeticNode < BaseNode
+        def evaluate(context)
+          left_value = elements[0].evaluate(context)
+          
+          # For more than two operands, we need to check if the next elemnt
+          # is a value or another arithmetic operation.
+          if elements[4].is_a?(Confuscript::Nodes::Expressions::ArithmeticNode)
+            right_value = elements[4].evaluate(context)
+          else
+            right_value = elements[4].evaluate(context)
+          end
+
+          operator.evaluate(left_value, right_value)
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/expressions/comparison_node.rb

@@ -0,0 +1,14 @@
+module Confuscript
+  module Nodes
+    module Expressions
+      class ComparisonNode < BaseNode
+        def evaluate(context)
+          left_value = elements[0].evaluate(context)
+          right_value = elements[4].evaluate(context)
+
+          comparison_operator.evaluate(left_value, right_value)
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/if_else_node.rb

@@ -0,0 +1,24 @@
+module Confuscript
+  module Nodes
+    class IfElseNode < BaseNode
+      # Since the condition is inverse, we evaluate the 'else' block if the condition is true
+      def evaluate(context)
+        if if_clause.comparison.evaluate(context)
+          else_clause.block.evaluate(context) if else_clause.respond_to?(:block)
+        else
+          if_clause.block.evaluate(context)
+        end
+      end
+
+      private
+
+      def if_clause
+        elements[0]
+      end
+
+      def else_clause
+        elements[2]
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/initialization_node.rb

@@ -0,0 +1,17 @@
+module Confuscript
+  module Nodes
+    class InitializationNode < BaseNode
+      def evaluate(context)
+        variable_name = variable.text_value
+
+        # Here's the basic idea: we initialize the variable with a default value or simply declare it.
+        # For now, we'll set the default value to nil.
+        context[variable_name] = nil
+
+        # Return the variable name for potential further processing or return nil
+        # Will need some thought on this one.
+        variable_name
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/loops/while_node.rb

@@ -0,0 +1,17 @@
+module Confuscript
+  module Nodes
+    module Loops
+      # Represents a while_loop node
+      class WhileNode < BaseNode
+        def evaluate(context)
+          comparison_node_element = elements[3]
+          block_node_element = elements[6]
+          
+          while comparison_node_element.evaluate(context) == false
+            block_node_element.evaluate(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/operators/addition_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    module Operators
+      class AdditionNode < BaseNode
+        def evaluate(left, right)
+          left + right
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/operators/division_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    module Operators
+      class DivisionNode < BaseNode
+        def evaluate(left, right)
+          left / right
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/operators/equality_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    module Operators
+      class EqualityNode < BaseNode
+        def evaluate(left, right)
+          left == right
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/operators/greater_than_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    module Operators
+      class GreaterThanNode < BaseNode
+        def evaluate(left, right)
+          left > right
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/operators/greater_than_or_equal_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    module Operators
+      class GreaterThanOrEqualNode < BaseNode
+        def evaluate(left, right)
+          left >= right
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/operators/less_than_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    module Operators
+      class LessThanNode < BaseNode
+        def evaluate(left, right)
+          left < right
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/operators/less_than_or_equal_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    module Operators
+      class LessThanOrEqualNode < BaseNode
+        def evaluate(left, right)
+          left <= right
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/operators/multiplication_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    module Operators
+      class MultiplicationNode < BaseNode
+        def evaluate(left, right)
+          left * right
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/operators/non_equality_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    module Operators
+      class NonEqualityNode < BaseNode
+        def evaluate(left, right)
+          left != right
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/operators/subtraction_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    module Operators
+      class SubtractionNode < BaseNode
+        def evaluate(left, right)
+          left - right
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/print/print_call_node.rb

@@ -0,0 +1,54 @@
+module Confuscript
+  module Nodes
+    module Print
+      # Represents a PrintCall node
+      class PrintCallNode < BaseNode
+        def evaluate(context)
+          print_name_element = elements[0]
+          print_arguments_element = elements[3]
+
+          print_name = print_name_element.text_value
+          raise Confuscript::SyntaxError, "Print #{print_name} not defined" unless context[print_name]
+
+          print_arguments = retrieve_arguments(print_arguments_element.elements, context)
+
+          begin
+            context[print_name].call(*print_arguments)
+          rescue Confuscript::VoidEncountered => e
+            e.value
+          end
+        end
+
+        private
+
+        # The normal structure for the elements is:
+        ##
+        # NumberNode offset=11, "5":
+          # SyntaxNode offset=11, "5",
+        # SyntaxNode offset=12, ", 2":
+          # SyntaxNode+Arguments0 offset=12, ", 2" (value,space1,space2):
+            # SyntaxNode offset=12, ""
+            # SyntaxNode offset=12, ","
+            # SyntaxNode offset=13, " ":
+              # SyntaxNode offset=13, " "
+            # NumberNode offset=14, "2":
+              # SyntaxNode offset=14, "2"
+        ## 
+        # There is a nested structure for the arguments
+        # This required a recursive print to retrieve the arguments
+        # from the elements
+        def retrieve_arguments(elements, context)
+          elements.flat_map do |element|
+            if element.respond_to?(:evaluate)
+              element.evaluate(context)
+            elsif element.elements
+              retrieve_arguments(element.elements, context)
+            else
+              nil
+            end
+          end.compact
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/print/print_definition_node.rb

@@ -0,0 +1,61 @@
+module Confuscript
+  module Nodes
+    module Print
+      # Represents a print definition node
+      class PrintDefinitionNode < BaseNode
+        def evaluate(context)
+          print_name = print_name_element.text_value
+          print_arguments = retrieve_arguments(print_arguments_element.elements, context)
+          print_body = print_body_element
+
+          # I don't know I think I'll have to create a proc here
+          # That will be used when printCallNode is evaluated
+          print = proc do |*args|
+            print_context = {}
+
+            print_arguments.each_with_index do |argument, index|
+              print_context[argument] = args[index]
+            end
+
+            print_body.evaluate(print_context)
+          end
+
+          # Some GuardRails to prevent overwriting
+          raise Confuscript::SyntaxError, "Print #{print_name} already defined" if context[print_name]
+
+          context[print_name] = print
+        end
+
+        def print_name_element
+          elements[2]
+        end
+
+        def print_arguments_element
+          elements[5]
+        end
+
+        def print_body_element
+          elements[8]
+        end
+
+        # Since the VariableNodes are deeply nested
+        # We need to deep search and fetch the VariableNodes
+        # This method recursively does that
+        # We have a same named method in PrintCallNode that does the same thing
+        # Except it evaluates the value instead of returning the text_value
+        # TODO: DRY out the code with PrintCallNode#retrieve_arguments
+        def retrieve_arguments(elements, context)
+          elements.flat_map do |element|
+            if element.is_a?(Confuscript::Nodes::Values::VariableNode)
+              element.text_value
+            elsif element.elements
+              retrieve_arguments(element.elements, context)
+            else
+              nil
+            end
+          end.compact
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/print/void_node.rb

@@ -0,0 +1,19 @@
+module Confuscript
+  module Nodes
+    module Print
+      # Represents a Void node
+      class VoidNode < BaseNode
+        def evaluate(context)
+          # I keep forgetting elements[1] is space
+          # We need to ensure that there is a space after void keyword
+          void_value_element = elements[2]
+          value = void_value_element.evaluate(context)
+
+          # THis is needed to break the chain
+          # and move out of the scope of the print
+          raise Confuscript::VoidEncountered.new("Void Encountered", value)
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/program_node.rb

@@ -0,0 +1,20 @@
+module Confuscript
+  module Nodes
+    class ProgramNode < BaseNode
+      def evaluate(context)
+        # Not the best way to evaluate
+        # TODO:- Revisit this
+        # Evaluate all children and return the result of the last one
+        children.map { |child| child.elements[0].evaluate(context) }.last
+      end
+
+      def children
+        elements[1]&.elements || []
+      end
+
+      def first_child
+        children.first&.elements&.first
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/values/boolean_node.rb

@@ -0,0 +1,14 @@
+module Confuscript
+  module Nodes
+    module Values
+      class BooleanNode < BaseNode
+        def evaluate(context)
+          # Return the value of the boolean
+          # I don't know if this is even correct but since it's working
+          # I'm going to leave it alone for now.
+          text_value == "true"
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/values/number_node.rb

@@ -0,0 +1,11 @@
+module Confuscript
+  module Nodes
+    module Values
+      class NumberNode < BaseNode
+        def evaluate(_context)
+          text_value.to_i
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/values/string_node.rb

@@ -0,0 +1,12 @@
+module Confuscript
+  module Nodes
+    module Values
+      class StringNode < BaseNode
+        def evaluate(context)
+          # Return the inner string of the node
+          text_value[1..-2] # Remove the quotes
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/nodes/values/variable_node.rb

@@ -0,0 +1,12 @@
+module Confuscript
+  module Nodes
+    module Values
+      class VariableNode < BaseNode
+        def evaluate(context)
+          # Return the value of the variable from the context
+          context[text_value]
+        end
+      end
+    end
+  end
+end

data/lib/confuscript/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Confuscript
+  VERSION = "0.1.0"
+end

data/lib/confuscript.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "treetop"
+
+require_relative "confuscript/version"
+
+require_relative "confuscript/nodes/base_node"
+require_relative "confuscript/nodes/program_node"
+require_relative "confuscript/nodes/console_input_node"
+require_relative "confuscript/nodes/comment_node"
+require_relative "confuscript/nodes/initialization_node"
+require_relative "confuscript/nodes/assignment_node"
+require_relative "confuscript/nodes/expression_node"
+require_relative "confuscript/nodes/if_else_node"
+require_relative "confuscript/nodes/block_node"
+
+# Expressions
+require_relative "confuscript/nodes/expressions/arithmetic_node"
+require_relative "confuscript/nodes/expressions/comparison_node"
+
+# Values
+require_relative "confuscript/nodes/values/variable_node"
+require_relative "confuscript/nodes/values/string_node"
+require_relative "confuscript/nodes/values/number_node"
+require_relative "confuscript/nodes/values/boolean_node"
+
+# Print
+require_relative "confuscript/nodes/print/print_definition_node"
+require_relative "confuscript/nodes/print/print_call_node"
+require_relative "confuscript/nodes/print/void_node"
+
+# Loops
+require_relative "confuscript/nodes/loops/while_node"
+
+# Operators
+require_relative "confuscript/nodes/operators/addition_node"
+require_relative "confuscript/nodes/operators/subtraction_node"
+require_relative "confuscript/nodes/operators/multiplication_node"
+require_relative "confuscript/nodes/operators/division_node"
+require_relative "confuscript/nodes/operators/equality_node"
+require_relative "confuscript/nodes/operators/non_equality_node"
+require_relative "confuscript/nodes/operators/greater_than_node"
+require_relative "confuscript/nodes/operators/less_than_node"
+require_relative "confuscript/nodes/operators/greater_than_or_equal_node"
+require_relative "confuscript/nodes/operators/less_than_or_equal_node"
+
+
+module Confuscript
+  class Error < StandardError; end
+  class SyntaxError < Error; end
+  class VoidEncountered < Error
+    attr_reader :value
+    
+    def initialize(message = "Void encountered", value = nil)
+      super(message)
+      @value = value
+    end
+  end
+
+  def self.parser
+    @parser ||= if File.file?("#{File.dirname(__FILE__)}/confuscript/grammar.rb")
+                  # Take compiled one
+                  require_relative "grammar"
+                else
+                  # Else compile and load
+                  Treetop.load "#{File.dirname(__FILE__)}/confuscript/grammar.treetop"
+                  ConfuscriptParser.new
+                end
+  end
+
+  def self.interpret(code)
+    ast = parser.parse(code)
+
+    # Check if parsing was successful
+    raise SyntaxError, parser.failure_reason if ast.nil?
+
+    # Create a new context
+    context = {}
+
+    # Evaluate the AST
+    ast.evaluate(context)
+
+    context
+  end
+end

data/sig/confuscript.rbs

@@ -0,0 +1,4 @@
+module Confuscript
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: confuscript
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Keshav Biswa
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-08-30 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- keshavbiswa21@gmail.com
+executables:
+- confuscript
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/factorial.notjs
+- examples/hello_world.notjs
+- examples/if_else.notjs
+- examples/palindrome.notjs
+- examples/print_definition.notjs
+- examples/while_loop.notjs
+- exe/confuscript
+- lib/confuscript.rb
+- lib/confuscript/grammar.treetop
+- lib/confuscript/nodes/assignment_node.rb
+- lib/confuscript/nodes/base_node.rb
+- lib/confuscript/nodes/block_node.rb
+- lib/confuscript/nodes/comment_node.rb
+- lib/confuscript/nodes/console_input_node.rb
+- lib/confuscript/nodes/expression_node.rb
+- lib/confuscript/nodes/expressions/arithmetic_node.rb
+- lib/confuscript/nodes/expressions/comparison_node.rb
+- lib/confuscript/nodes/if_else_node.rb
+- lib/confuscript/nodes/initialization_node.rb
+- lib/confuscript/nodes/loops/while_node.rb
+- lib/confuscript/nodes/operators/addition_node.rb
+- lib/confuscript/nodes/operators/division_node.rb
+- lib/confuscript/nodes/operators/equality_node.rb
+- lib/confuscript/nodes/operators/greater_than_node.rb
+- lib/confuscript/nodes/operators/greater_than_or_equal_node.rb
+- lib/confuscript/nodes/operators/less_than_node.rb
+- lib/confuscript/nodes/operators/less_than_or_equal_node.rb
+- lib/confuscript/nodes/operators/multiplication_node.rb
+- lib/confuscript/nodes/operators/non_equality_node.rb
+- lib/confuscript/nodes/operators/subtraction_node.rb
+- lib/confuscript/nodes/print/print_call_node.rb
+- lib/confuscript/nodes/print/print_definition_node.rb
+- lib/confuscript/nodes/print/void_node.rb
+- lib/confuscript/nodes/program_node.rb
+- lib/confuscript/nodes/values/boolean_node.rb
+- lib/confuscript/nodes/values/number_node.rb
+- lib/confuscript/nodes/values/string_node.rb
+- lib/confuscript/nodes/values/variable_node.rb
+- lib/confuscript/version.rb
+- sig/confuscript.rbs
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: A new confusing programming language.
+test_files: []