kaiser-ruby 0.5.1 → 0.7

data/lib/kaiser_ruby/refinements.rb

@@ -0,0 +1,200 @@
+module KaiserRuby
+  module Refinements
+    refine NilClass do
+      def to_bool
+        false
+      end
+
+      def +(other)
+        'mysterious' + other if other.is_a?(String)
+      end
+
+      def -(other)
+        'mysterious' + other if other.is_a?(String)
+      end
+
+      def to_s
+        'mysterious'
+      end
+    end
+
+    refine Float do
+      alias_method :old_add, :+
+      alias_method :old_mul, :*
+      alias_method :old_div, :/
+      alias_method :old_gt, :<
+      alias_method :old_gte, :<=
+      alias_method :old_lt, :>
+      alias_method :old_lte, :>=
+      alias_method :old_eq, :==
+
+      def to_bool
+        self.zero? ? false : true
+      end
+
+      def +(other)
+        other.is_a?(String) ? self.to_s + other : self.old_add(other)
+      end
+
+      def *(other)
+        other.is_a?(String) ? other * self : self.old_mul(other)
+      end
+
+      def /(other)
+        raise ZeroDivisionError if other.zero?
+        self.old_div(other)
+      end
+
+      def <(other)
+        other.is_a?(String) ? self < Float(other) : self.old_gt(other)
+      end
+
+      def <=(other)
+        other.is_a?(String) ? self <= Float(other) : self.old_gte(other)
+      end
+
+      def >(other)
+        other.is_a?(String) ? self > Float(other) : self.old_lt(other)
+      end
+
+      def >=(other)
+        other.is_a?(String) ? self >= Float(other) : self.old_lte(other)
+      end
+
+      def ==(other)
+        if other.is_a?(TrueClass) || other.is_a?(FalseClass)
+          self.to_bool == other
+        elsif other.is_a?(String)
+          t = Float(other) rescue other
+          self.old_eq(t)
+        else
+          self.old_eq(other)
+        end
+      end
+    end
+
+    refine String do
+      alias_method :old_add, :+
+      alias_method :old_gt, :<
+      alias_method :old_gte, :<=
+      alias_method :old_lt, :>
+      alias_method :old_lte, :>=
+      alias_method :old_eq, :==
+
+      def to_bool
+        self.size == 0 ? false : true
+      end
+
+      def __booleanize
+        if self =~ /\A\bfalse\b|\bno\b|\blies\b|\bwrong\b\Z/i
+          return false
+        elsif self =~ /\A\btrue\b|\byes\b|\bok\b|\bright\b\Z/i
+          return true
+        end
+
+        return self
+      end
+
+      def +(other)
+        other.is_a?(String) ? self.old_add(other) : self + other.to_s
+      end
+
+      def <(other)
+        other.is_a?(Float) ? Float(self) < other : self.old_gt(other)
+      end
+
+      def <=(other)
+        other.is_a?(Float) ? Float(self) <= other : self.old_gte(other)
+      end
+
+      def >(other)
+        other.is_a?(Float) ? Float(self) > other : self.old_lt(other)
+      end
+
+      def >=(other)
+        other.is_a?(Float) ? Float(self) >= other : self.old_lte(other)
+      end
+
+      def ==(other)
+        if other.is_a?(TrueClass) || other.is_a?(FalseClass)
+          self.__booleanize == other
+        elsif other.is_a?(Float)
+          t = Float(self) rescue self
+          t == other
+        else
+          self.old_eq(other)
+        end
+      end
+    end
+
+    refine TrueClass do
+      alias_method :old_eq, :==
+
+      def to_bool
+        true
+      end
+
+      def +(other)
+        return 'true' + other if other.is_a?(String)
+        other.even? ? self : !self
+      end
+
+      def -(other)
+        other.even? ? self : !self
+      end
+
+      def ==(other)
+        if other.is_a?(Float)
+          self == other.to_bool
+        elsif other.is_a?(String)
+          self.old_eq(other.__booleanize)
+        else
+          self.old_eq(other)
+        end
+      end
+    end
+
+    refine FalseClass do
+      alias_method :old_eq, :==
+
+      def to_bool
+        false
+      end
+
+      def +(other)
+        return 'false' + other if other.is_a?(String)
+        other.even? ? self : !self
+      end
+
+      def -(other)
+        other.even? ? self : !self
+      end
+
+      def ==(other)
+        if other.is_a?(Float)
+          self == other.to_bool
+        elsif other.is_a?(String)
+          self.old_eq(other.__booleanize)
+        else
+          self.old_eq(other)
+        end
+      end
+    end
+
+    refine BasicObject do
+      alias_method :old_not, :!
+
+      def !
+        if self.is_a?(String)
+          return self.size == 0 ? true : false
+        elsif self.is_a?(Float)
+          return self.zero? ? true : false
+        elsif self.is_a?(NilClass)
+          return true
+        else
+          self.old_not
+        end
+      end
+    end
+  end
+end

data/lib/kaiser_ruby/transformer.rb

@@ -0,0 +1,358 @@
+module KaiserRuby
+  class Transformer
+    attr_reader :parsed_tree, :output
+
+    def initialize(tree)
+      @parsed_tree = tree
+      @output = []
+      @method_names = []
+      @nesting = 0
+      @indentation = ''
+      @lnum = 0
+    end
+
+    def transform
+      @last_variable = nil # name of last used variable for pronouns
+      @else_already = nil # line number of a current if block, so we can avoid double else
+      @local_variables = [] # locally defined variable names in current function block
+
+      @parsed_tree.each_with_index do |line_object, lnum|
+        @lnum = lnum
+        transformed_line = select_transformer(line_object)
+        if line_object[:nesting]
+          @nesting = line_object[:nesting]
+        else
+          @nesting = 0
+        end
+
+        @indentation = '  ' * @nesting
+        @output << @indentation + transformed_line
+      end
+
+      # at end of file, close all the blocks that are still started
+      while @nesting > 0
+        @nesting -= 1
+        @indentation = '  ' * @nesting
+        @output << @indentation + "end"
+      end
+
+      @output << '' if @output.size > 1
+      @output.join("\n")
+    end
+
+    def select_transformer(object)
+      key = object.keys.first
+      send("transform_#{key}", object)
+    end
+
+    def method_missing(m, *args, &block)
+      raise ArgumentError, "missing Transform rule: #{m}, #{args}"
+    end
+
+    # transform language tree into Ruby
+
+    def transform_print(object)
+      var = select_transformer(object[:print])
+      "puts #{var}"
+    end
+
+    def transform_listen_to(object)
+      var = select_transformer(object[:listen_to])
+      "print '> '\n__input = $stdin.gets.chomp\n#{var} = Float(__input) rescue __input"
+    end
+
+    def transform_listen(_object)
+      "print '> '\n$stdin.gets.chomp"
+    end
+
+    def transform_return(object)
+      raise KaiserRuby::RockstarSyntaxError, "Return used outside of a function" if object[:nesting].to_i.zero?
+      var = select_transformer(object[:return])
+      "return #{var}"
+    end
+
+    def transform_continue(object)
+      raise KaiserRuby::RockstarSyntaxError, "Continue used outside of a loop" if object[:nesting].to_i.zero?
+      "next"
+    end
+
+    def transform_break(object)
+      raise KaiserRuby::RockstarSyntaxError, "Break used outside of a loop" if object[:nesting].to_i.zero?
+      "break"
+    end
+
+    def transform_variable_name(object)
+      varname = object[:variable_name]
+      if object[:type] == :assignment
+        if @local_variables.empty?
+          varname = "@#{varname}"
+        else
+          @local_variables << varname
+        end
+      else  
+        unless @local_variables.include?(varname) 
+          varname = @method_names.include?(varname) ? varname : "@#{varname}" 
+        end
+      end
+
+      @last_variable = varname
+      varname
+    end
+
+    def transform_local_variable_name(object)
+      object[:local_variable_name]
+    end
+
+    def transform_function_name(object)
+      object[:function_name]
+    end
+
+    def transform_pronoun(_object)
+      @last_variable
+    end
+
+    def transform_string(object)
+      object[:string]
+    end
+
+    def transform_number(object)
+      object[:number]
+    end
+
+    def transform_argument_list(object)
+      list = []
+      object[:argument_list].each do |arg|
+        list << select_transformer(arg)
+      end
+
+      list.join(', ')
+    end
+
+    def transform_addition(object)
+      left = select_transformer(object[:addition][:left])
+      right = select_transformer(object[:addition][:right])
+      "#{left} + #{right}"
+    end
+
+    def transform_multiplication(object)
+      left = select_transformer(object[:multiplication][:left])
+      right = select_transformer(object[:multiplication][:right])
+      "#{left} * #{right}"
+    end
+
+    def transform_subtraction(object)
+      left = select_transformer(object[:subtraction][:left])
+      right = select_transformer(object[:subtraction][:right])
+      "#{left} - #{right}"
+    end
+
+    def transform_division(object)
+      left = select_transformer(object[:division][:left])
+      right = select_transformer(object[:division][:right])
+      "#{left} / #{right}"
+    end
+
+    def transform_assignment(object)
+      left = select_transformer(object[:assignment][:left])
+      right = select_transformer(object[:assignment][:right])
+      "#{left} = #{right}"
+    end
+
+    def transform_decrement(object)
+      argument = select_transformer(object[:decrement])
+      amount = object.dig(:decrement, :amount)
+      "#{argument} -= #{amount}"
+    end
+
+    def transform_increment(object)
+      argument = select_transformer(object[:increment])
+      amount = object.dig(:increment, :amount)
+      "#{argument} += #{amount}"
+    end
+
+    def transform_function_call(object)
+      func_name = select_transformer(object[:function_call][:left])
+      argument = select_transformer(object[:function_call][:right])
+
+      "#{func_name}(#{argument})"
+    end
+
+    def transform_passed_function_call(object)
+      return transform_function_call(object[:passed_function_call])
+    end
+
+    def transform_poetic_string(object)
+      var = select_transformer(object[:poetic_string][:left])
+      value = select_transformer(object[:poetic_string][:right])
+
+      "#{var} = #{value}"
+    end
+
+    def transform_poetic_type(object)
+      var = select_transformer(object[:poetic_type][:left])
+      value = select_transformer(object[:poetic_type][:right])
+      "#{var} = #{value}"
+    end
+
+    def transform_poetic_number(object)
+      var = select_transformer(object[:poetic_number][:left])
+      value = select_transformer(object[:poetic_number][:right])
+      "#{var} = #{value}"
+    end
+
+    def transform_number_literal(object)
+      string = object[:number_literal]
+      if string.include?('.')
+        string.split('.', 2).map do |sub|
+          str_to_num(sub.strip)
+        end.join('.').to_f
+      else
+        str_to_num(string).to_f
+      end
+    end
+
+    def transform_type(object)
+      case object[:type]
+      when "nil"
+        'nil'
+      when "null"
+        '0.0'
+      when "true"
+        'true'
+      when "false"
+        'false'
+      end
+    end
+
+    def transform_empty_line(_object)
+      if @nesting == 0
+        return ""
+      elsif @nesting == 1
+        @local_variables = []
+        return "end\n"
+      else
+        @else_already = nil
+        return "end\n"
+      end
+    end
+
+    def additional_argument_transformation(argument)
+      # testing function existence 
+      arg = @method_names.include?(argument) ? "defined?(#{argument})" : argument
+
+      # single variable without any operator needs to return a refined boolean
+      arg = "#{arg}.to_bool" if arg !~ /==|>|>=|<|<=|!=/
+
+      return arg
+    end
+
+    def transform_if(object)
+      argument = select_transformer(object[:if][:argument])
+      argument = additional_argument_transformation(argument)
+      "if #{argument}"
+    end
+
+    def transform_else(object)
+      raise KaiserRuby::RockstarSyntaxError, "Else outside an if block" if object[:nesting].to_i.zero?
+      raise KaiserRuby::RockstarSyntaxError, "Double else inside if block" if @else_already != nil && object[:nesting_start_line] == @else_already
+
+      @else_already = object[:nesting_start_line]
+      "else"
+    end
+
+    def transform_while(object)
+      argument = select_transformer(object[:while][:argument])
+      argument = additional_argument_transformation(argument)
+      "while #{argument}"
+    end
+
+    def transform_until(object)
+      argument = select_transformer(object[:until][:argument])
+      argument = additional_argument_transformation(argument)
+      "until #{argument}"
+    end
+
+    def transform_equality(object)
+      left = select_transformer(object[:equality][:left])
+      right = select_transformer(object[:equality][:right])
+      "#{left} == #{right}"
+    end
+
+    def transform_inequality(object)
+      left = select_transformer(object[:inequality][:left])
+      right = select_transformer(object[:inequality][:right])
+      "#{left} != #{right}"
+    end
+
+    def transform_gt(object)
+      left = select_transformer(object[:gt][:left])
+      right = select_transformer(object[:gt][:right])
+      "#{left} > #{right}"
+    end
+
+    def transform_gte(object)
+      left = select_transformer(object[:gte][:left])
+      right = select_transformer(object[:gte][:right])
+      "#{left} >= #{right}"
+    end
+
+    def transform_lt(object)
+      left = select_transformer(object[:lt][:left])
+      right = select_transformer(object[:lt][:right])
+      "#{left} < #{right}"
+    end
+
+    def transform_lte(object)
+      left = select_transformer(object[:lte][:left])
+      right = select_transformer(object[:lte][:right])
+      "#{left} <= #{right}"
+    end
+
+    def transform_function(object)
+      funcname = transform_function_name(object[:function][:name])
+      argument = select_transformer(object[:function][:argument])
+
+      # save method name and make local variables out of the function arguments
+      @method_names << funcname
+      @local_variables = argument.split(', ')
+
+      "def #{funcname}(#{argument})"
+    end
+
+    def transform_and(object)
+      left = select_transformer(object[:and][:left])
+      right = select_transformer(object[:and][:right])
+
+      "#{left} && #{right}"
+    end
+
+    def transform_not(object)
+      arg = select_transformer(object[:not])
+      "!#{arg}"
+    end
+
+    def transform_or(object)
+      left = select_transformer(object[:or][:left])
+      right = select_transformer(object[:or][:right])
+
+      "#{left} || #{right}"
+    end
+
+    def transform_nor(object)
+      left = select_transformer(object[:nor][:left])
+      right = select_transformer(object[:nor][:right])
+
+      "!(#{left} || #{right})"
+    end
+
+    # private
+
+    def str_to_num(string)
+      filter_string(string).map { |e| e.length % 10 }.join
+    end
+
+    def filter_string(string, rxp: /[[:alpha:]]/)
+      string.to_s.split(/\s+/).map { |e| e.chars.select { |c| c =~ rxp }.join }.reject { |a| a.empty? }
+    end
+  end
+end