esolang 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 48161d9cd63a90d101a9f5936464c053d2295b9ef7b500c95ad3cb2ff3049dc7
+  data.tar.gz: 4c570f8ff4b1de1c7c115572e1d3ab06a8d84015936a82ecfdcd98396b7fea24
+SHA512:
+  metadata.gz: 8777ec08eac7ae40588d31fb178b9ebee874f12fd9847eba36c52132312e9c96db43113e970fa0632be4c70bac9569b0d4bd6c5d96cd33093f1a5b3812e21bf9
+  data.tar.gz: e9033263c0ea899c52be1a33c968c2b3ca667bf3f6a35b14f70a6cb7e457b7a0e95e018b6cda2beed83b198f743adf735bde5bd0cb6742d367d2adbf10eead89

data/lib/esolang.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative '../lib/interpreters/boolfuck_interpreter.rb'
+require_relative '../lib/interpreters/smallfuck_interpreter.rb'
+require_relative '../lib/interpreters/paintfuck_interpreter.rb'
+require_relative '../lib/interpreters/brainfuck_interpreter.rb'
+require_relative '../lib/interpreters/ook_interpreter.rb'
+
+require_relative '../lib/refinements/refinements.rb'
+
+# The Esolang module provides methods to interpret esoteric programming languages.
+#
+# To use it you need to:
+  #
+  # ```ruby
+  # using Esolang::Refinements
+  # ```
+module Esolang
+  # Interprets Boolfuck code.
+  #
+  # @param code [String] The Boolfuck code to interpret.
+  # @param input [String] The input for the Boolfuck program (optional).
+  # @return [String] The result of the Boolfuck interpretation.
+  def self.boolfuck(code, input = '')
+    Interpreters::Boolfuck.new(code, input).run
+  end
+
+  # Interprets Smallfuck code.
+  #
+  # @param code [String] The Smallfuck code to interpret.
+  # @param tape [String] The initial tape state for the Smallfuck program.
+  # @return [String] The result of the Smallfuck interpretation.
+  def self.smallfuck(code, tape)
+    Interpreters::Smallfuck.new(code, tape).run
+  end
+
+  # Interprets Paintfuck code.
+  #
+  # @param code [String] The Paintfuck code to interpret.
+  # @param iterations [Integer] The number of iterations for the Paintfuck program.
+  # @param width [Integer] The width of the Paintfuck canvas.
+  # @param height [Integer] The height of the Paintfuck canvas.
+  # @return [String] The result of the Paintfuck interpretation.
+  def self.paintfuck(code, iterations, width, height)
+    Interpreters::Paintfuck.new(code, iterations, width, height).run
+  end
+
+  # Interprets Brainfuck code.
+  #
+  # @param code [String] The Brainfuck code to interpret.
+  # @param input [String] The input for the Brainfuck program (optional).
+  # @return [String] The result of the Brainfuck interpretation.
+  def self.brainfuck(code, input = '')
+    Interpreters::Brainfuck.new(code, input).run
+  end
+
+  # Interprets Ook! code.
+  #
+  # @param code [String] The Ook! code to interpret.
+  # @param input [String] The input for the Ook! program (optional).
+  # @return [String] The result of the Ook! interpretation.
+  def self.ook(code, input = '')
+    Interpreters::Ook.new(code, input).run
+  end
+end

data/lib/interpreters/base_interpreter.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Esolang
+  module Interpreters
+    # The BaseInterpreter class provides a common interface and basic functionality for
+    # interpreting esoteric programming languages.
+    class BaseInterpreter
+      # Initializes a new instance of the BaseInterpreter class.
+      #
+      # @param code [String] The code to interpret.
+      def initialize(code)
+        @code = code.chars
+        @code_pointer = 0
+        @loop_map = create_loop_map
+        @tape_pointer = 0
+      end
+
+      # Executes the interpretation of the code. Subclasses must implement this method.
+      #
+      # @abstract Subclasses must implement the run method.
+      # @raise [NotImplementedError] Raised if the method is not implemented by subclasses.
+      def run
+        raise NotImplementedError, 'Subclasses must implement the run method'
+      end
+
+      private
+
+      # Moves the tape pointer to the right.
+      def move_right
+        @tape_pointer += 1
+      end
+
+      # Moves the tape pointer to the left.
+      def move_left
+        @tape_pointer -= 1
+      end
+
+      # Reads input and writes it to the tape.
+      def input_to_tape
+        @input.empty? ? current_bit(0) : current_bit(@input.shift)
+      end
+
+      # Reads the tape and appends the current bit to the output array.
+      def tape_to_output_array
+        @output << current_bit
+      end
+
+      # Creates a map of loop indices for efficient loop navigation.
+      def create_loop_map
+        map = {}
+        stack = []
+
+        @code.each_with_index do |command, index|
+          case command
+          when '[' then stack << index
+          when ']'
+            if stack.empty?
+              raise StandardError, "Invalid code: No matching '[' for ']' at index #{index}"
+            else
+              map[stack.pop] = index
+            end
+          end
+        end
+
+        raise StandardError, "Invalid code: No matching ']' for '[' at index #{stack.last}" unless stack.empty?
+
+        map
+      end
+
+      # Jumps to the matching ']' if the current bit is zero.
+      def loop_begin
+        return unless current_bit.zero?
+
+        @code_pointer = @loop_map[@code_pointer]
+      end
+
+      # Jumps back to the matching '[' if the current bit is non-zero.
+      def loop_end
+        return if current_bit.zero?
+
+        @code_pointer = @loop_map.key(@code_pointer)
+      end
+
+      # Flips the current bit.
+      def flip
+        current_bit(current_bit ^ 1)
+      end
+
+      # Retrieves the value of the current bit. Subclasses must implement this method.
+      #
+      # @abstract Subclasses must implement the current_bit method.
+      # @raise [NotImplementedError] Raised if the method is not implemented by subclasses.
+      def current_bit
+        raise NotImplementedError, 'Subclasses must implement the current_bit method'
+      end
+
+      # Checks if the interpreter is still running (code execution is not completed).
+      def running?
+        @code_pointer < @code.length
+      end
+
+      # Retrieves the current command in the code.
+      def command
+        @code[@code_pointer]
+      end
+    end
+  end
+end

data/lib/interpreters/boolfuck_interpreter.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'base_interpreter'
+
+module Esolang
+  module Interpreters
+    # The Boolfuck class represents an interpreter for the Boolfuck esoteric programming language.
+    class Boolfuck < BaseInterpreter
+      # Initializes a new instance of the Boolfuck interpreter.
+      #
+      # @param code [String] The Boolfuck code to interpret.
+      # @param input [String] The input for the Boolfuck program (optional).
+      def initialize(code, input = '')
+        super(code.gsub(/[^,\.;<>\+\[\]]/, ''))
+        @input = chars_to_bits(input)
+        @output = []
+        @tape = Hash.new(0)
+      end
+
+      # Executes the interpretation of the Boolfuck code.
+      #
+      # @return [String] The result of the Boolfuck interpretation.
+      def run
+        while running? do
+          case command
+          when ',' then input_to_tape
+          when ';' then tape_to_output_array
+          when '>' then move_right
+          when '<' then move_left
+          when '+' then flip
+          when '[' then loop_begin
+          when ']' then loop_end
+          end
+
+          @code_pointer += 1
+        end
+
+        translate_output_bits_to_chars
+      end
+
+      private
+
+      # Converts characters to bits (0 or 1).
+      #
+      # @param chars [String] The characters to convert.
+      # @return [Array<Integer>] The array of bits.
+      def chars_to_bits(chars)
+        chars.chars.map { |char| [char.ord].pack("C*").unpack("b*")[0] }.join.chars.map(&:to_i)
+      end
+
+      # Retrieves or updates the value of the current bit on the tape.
+      #
+      # @param new_value [Integer] The new value for the current bit (optional).
+      # @return [Integer] The value of the current bit.
+      def current_bit(new_value = nil)
+        @tape[@tape_pointer] = new_value unless new_value.nil?
+
+        @tape[@tape_pointer]
+      end
+
+      # Translates the bits in the output array to characters.
+      #
+      # @return [String] The translated characters.
+      def translate_output_bits_to_chars
+        zeros_count_to_fill = (@output.length % 8).zero? ? 0 : 8 - (@output.length % 8)
+
+        @output.fill(0, @output.length, zeros_count_to_fill).each_slice(8).map do |byte|
+          byte.join.reverse.to_i(2).chr
+        end.join
+      end
+    end
+  end
+end

data/lib/interpreters/brainfuck_interpreter.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'base_interpreter'
+
+module Esolang
+  module Interpreters
+    # The Brainfuck class represents an interpreter for the Brainfuck esoteric programming language.
+    class Brainfuck < BaseInterpreter
+      # Initializes a new instance of the Brainfuck interpreter.
+      #
+      # @param code [String] The Brainfuck code to interpret.
+      # @param input [String] The input for the Brainfuck program (optional).
+      def initialize(code, input = '')
+        # Added ? to valid chars for compatibility with Ook! But don't parse ? in Brainfuck
+        super(code.gsub(/[^\?,\.<>\+-\[\]]/, ''))
+        @input = chars_to_bytes(input)
+        @output = []
+        @tape = Hash.new(0)
+      end
+
+      # Executes the interpretation of the Brainfuck code.
+      #
+      # @return [String] The result of the Brainfuck interpretation.
+      def run
+        while running? do
+          case command
+          when ',' then input_to_tape
+          when '.' then tape_to_output_array
+          when '>' then move_right
+          when '<' then move_left
+          when '+' then increment
+          when '-' then decrement
+          when '[' then loop_begin
+          when ']' then loop_end
+          end
+
+          @code_pointer += 1
+        end
+
+        translate_output_bytes_to_chars
+      end
+
+      private
+
+      # Increments the value of the current bit on the tape.
+      def increment
+        current_bit((current_bit + 1) % 256)
+      end
+
+      # Decrements the value of the current bit on the tape.
+      def decrement
+        current_bit((current_bit - 1) % 256)
+      end
+
+      # Converts characters to byte values.
+      #
+      # @param chars [String] The characters to convert.
+      # @return [Array<Integer>] The array of byte values.
+      def chars_to_bytes(chars)
+        chars.chars.map { |char| char.ord }
+      end
+
+      # Retrieves or updates the value of the current bit on the tape.
+      #
+      # @param new_value [Integer] The new value for the current bit (optional).
+      # @return [Integer] The value of the current bit.
+      def current_bit(new_value = nil)
+        @tape[@tape_pointer] = new_value unless new_value.nil?
+
+        @tape[@tape_pointer]
+      end
+
+      # Translates the byte values in the output array to characters.
+      #
+      # @return [String] The translated characters.
+      def translate_output_bytes_to_chars
+        @output.map { |char| char.chr }.join
+      end
+    end
+  end
+end

data/lib/interpreters/ook_interpreter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'brainfuck_interpreter'
+
+module Esolang
+  module Interpreters
+    # The Ook class represents an interpreter for the Ook! esoteric programming language,
+    # which is translated to Brainfuck for execution.
+    class Ook < Brainfuck
+      # Initializes a new instance of the Ook interpreter.
+      #
+      # @param code [String] The Ook code to interpret.
+      # @param input [String] The input for the Ook program (optional).
+      def initialize(code, input = '')
+        super(translate_to_brainfuck(code), input)
+        @input = input
+      end
+
+      # Executes the interpretation of the Ook code.
+      #
+      # @return [String] The result of the Ook interpretation.
+      def run
+        while running? do
+          case command
+          when ',' then input_to_tape
+          when '.' then tape_to_output_array
+          when '>' then move_right
+          when '<' then move_left
+          when '+' then increment
+          when '-' then decrement
+          when '[' then loop_begin
+          when ']' then loop_end
+          when '?' then banana
+          end
+
+          @code_pointer += 1
+        end
+
+        translate_output_bytes_to_chars
+      end
+
+      private
+
+      # Translates Ook! code to Brainfuck code.
+      #
+      # @param code [String] The Ook code to translate.
+      # @return [String] The translated Brainfuck code.
+      def translate_to_brainfuck(code)
+        code.gsub(/[^\.\!\?]/, '').chars.each_slice(2).map do |command|
+          case command.join
+          when ".?" then ">"
+          when "?." then "<"
+          when ".." then "+"
+          when "!!" then "-"
+          when "!." then "."
+          when ".!" then ","
+          when "!?" then "["
+          when "?!" then "]"
+          when "??" then "?"
+          end
+        end.join
+      end
+
+      # Prints a message indicating that the memory pointer got a banana.
+      def banana
+        puts "The memory pointer got a banana"
+      end
+    end
+  end
+end

data/lib/interpreters/paintfuck_interpreter.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative 'base_interpreter'
+
+module Esolang
+  module Interpreters
+    # The Paintfuck class represents an interpreter for the Paintfuck esoteric programming language.
+    class Paintfuck < BaseInterpreter
+      # Initializes a new instance of the Paintfuck interpreter.
+      #
+      # @param code [String] The Paintfuck code to interpret.
+      # @param iterations [Integer] The number of iterations for the Paintfuck program.
+      # @param width [Integer] The width of the Paintfuck canvas.
+      # @param height [Integer] The height of the Paintfuck canvas.
+      def initialize(code, iterations, width, height)
+        super(code.gsub(/[^nesw\*\[\]]/, ''))
+        @iterations = iterations
+        @width = width
+        @height = height
+        @data_grid = generate_zero_grid
+        @grid_pointer = [0, 0]
+      end
+
+      # Executes the interpretation of the Paintfuck code.
+      #
+      # @return [String] The result of the Paintfuck interpretation.
+      def run
+        while running? do
+          case command
+          when 'n' then move_up
+          when 'e' then move_right
+          when 's' then move_down
+          when 'w' then move_left
+          when '*' then flip
+          when '[' then loop_begin
+          when ']' then loop_end
+          end
+
+          @code_pointer += 1
+          @iterations -= 1
+        end
+
+        output
+      end
+
+      private
+
+      # Moves the grid pointer up.
+      def move_up
+        @grid_pointer[0] = (@grid_pointer.first - 1 + @height) % @height
+      end
+
+      # Moves the grid pointer down.
+      def move_down
+        @grid_pointer[0] = (@grid_pointer.first + 1 + @height) % @height
+      end
+
+      # Moves the grid pointer right.
+      def move_right
+        @grid_pointer[1] = (@grid_pointer.last + 1 + @width) % @width
+      end
+
+      # Moves the grid pointer left.
+      def move_left
+        @grid_pointer[1] = (@grid_pointer.last - 1 + @width) % @width
+      end
+
+      # Retrieves or updates the value of the current bit on the Paintfuck canvas.
+      #
+      # @param new_value [Integer] The new value for the current bit (optional).
+      # @return [Integer] The value of the current bit.
+      def current_bit(new_value = nil)
+        @data_grid[@grid_pointer.first][@grid_pointer.last] = new_value unless new_value.nil?
+
+        @data_grid[@grid_pointer.first][@grid_pointer.last]
+      end
+
+      # Retrieves the output of the Paintfuck program.
+      #
+      # @return [String] The Paintfuck canvas as a string.
+      def output
+        @data_grid
+          .map { |row| row.join }
+          .join("\r\n")
+      end
+
+      # Generates a canvas grid filled with zeros.
+      #
+      # @return [Array<Array<Integer>>] The zero-filled grid.
+      def generate_zero_grid
+        (1..@height).map { [0] * @width }
+      end
+
+      # Checks if the interpreter is still running (code execution is not completed).
+      #
+      # @return [Boolean] Returns true if the interpreter is still running, otherwise false.
+      def running?
+        @iterations.positive? && super
+      end
+    end
+  end
+end

data/lib/interpreters/smallfuck_interpreter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'base_interpreter'
+
+module Esolang
+  module Interpreters
+    # The Smallfuck class represents an interpreter for the Smallfuck esoteric programming language.
+    class Smallfuck < BaseInterpreter
+      # Initializes a new instance of the Smallfuck interpreter.
+      #
+      # @param code [String] The Smallfuck code to interpret.
+      # @param tape [String] The initial tape state for the Smallfuck program.
+      def initialize(code, tape)
+        super(code.gsub(/[^<>\*\[\]]/, ''))
+        @tape = tape.chars.map(&:to_i)
+      end
+
+      # Executes the interpretation of the Smallfuck code.
+      #
+      # @return [String] The result of the Smallfuck interpretation.
+      def run
+        while running? do
+          case command
+          when '>' then move_right
+          when '<' then move_left
+          when '*' then flip
+          when '[' then loop_begin
+          when ']' then loop_end
+          end
+          @code_pointer += 1
+        end
+        @tape.join
+      end
+
+      private
+
+      # Checks if the interpreter is still running (code execution is not completed).
+      #
+      # @return [Boolean] Returns true if the interpreter is still running, otherwise false.
+      def running?
+        @tape_pointer < @tape.length &&
+        @tape_pointer >= 0 &&
+        super
+      end
+
+      # Retrieves or updates the value of the current bit on the tape.
+      #
+      # @param new_value [Integer] The new value for the current bit (optional).
+      # @return [Integer] The value of the current bit.
+      def current_bit(new_value = nil)
+        @tape[@tape_pointer] = new_value unless new_value.nil?
+
+        @tape[@tape_pointer]
+      end
+    end
+  end
+end

data/lib/refinements/refinements.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Esolang
+  # The Refinements module provides refinements for String class to enable
+  # direct interpretation of esoteric programming languages.
+  #
+  # To use these refinements, you need to include them using the `using` keyword:
+  #
+  # ```ruby
+  # require 'esolang'
+  # ```
+  module Refinements
+    # Refines the String class to provide a convenient method for interpreting Boolfuck code.
+    refine String do
+      # Interprets Boolfuck code directly on a String.
+      #
+      # @param input [String] The input for the Boolfuck program (optional).
+      # @return [String] The result of the Boolfuck interpretation.
+      def boolfuck(input = '')
+        Esolang::Interpreters::Boolfuck.new(self, input).run
+      end
+
+      # Interprets Smallfuck code directly on a String.
+      #
+      # @param tape [String] The initial tape state for the Smallfuck program.
+      # @return [String] The result of the Smallfuck interpretation.
+      def smallfuck(tape)
+        Esolang::Interpreters::Smallfuck.new(self, tape).run
+      end
+
+      # Interprets Paintfuck code directly on a String.
+      #
+      # @param iterations [Integer] The number of iterations for the Paintfuck program.
+      # @param width [Integer] The width of the Paintfuck canvas.
+      # @param height [Integer] The height of the Paintfuck canvas.
+      # @return [String] The result of the Paintfuck interpretation.
+      def paintfuck(iterations, width, height)
+        Esolang::Interpreters::Paintfuck.new(self, iterations, width, height).run
+      end
+
+      # Interprets Brainfuck code directly on a String.
+      #
+      # @param input [String] The input for the Brainfuck program (optional).
+      # @return [String] The result of the Brainfuck interpretation.
+      def brainfuck(input = '')
+        Esolang::Interpreters::Brainfuck.new(self, input).run
+      end
+
+      # Interprets Ook! code directly on a String.
+      #
+      # @param input [String] The input for the Ook! program (optional).
+      # @return [String] The result of the Ook! interpretation.
+      def ook(input = '')
+        Esolang::Interpreters::Ook.new(self, input).run
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: esolang
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Daniel Kipp
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-01-22 00:00:00.000000000 Z
+dependencies: []
+description: |-
+  A gem for working with esoteric programming languages.
+                          Usage: require 'esolang'; using Esolang::Refinements
+                          Adds string refinements, usage: e.g. 'code_string'.boolfuck('user_input'). Alternative usage: e.g. Esolang.boolfuck(code, input)
+email:
+- daniel.kipp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/esolang.rb
+- lib/interpreters/base_interpreter.rb
+- lib/interpreters/boolfuck_interpreter.rb
+- lib/interpreters/brainfuck_interpreter.rb
+- lib/interpreters/ook_interpreter.rb
+- lib/interpreters/paintfuck_interpreter.rb
+- lib/interpreters/smallfuck_interpreter.rb
+- lib/refinements/refinements.rb
+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: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Interpreter gem for different Esolangs
+test_files: []