nilac 0.0.4.3.9.2 → 0.0.4.3.9.3

data/lib/nilac/compile_operators.rb

@@ -0,0 +1,83 @@
+  def compile_operators(input_file_contents)
+
+    def compile_power_operator(input_string)
+
+      matches = input_string.scan(/(\w{1,}\*\*\w{1,})/).to_a.flatten
+
+      unless matches.empty?
+
+        matches.each do |match|
+
+          left, right = match.split("**")
+
+          input_string = input_string.sub(match, "Math.pow(#{left},#{right})")
+
+        end
+
+      end
+
+      return input_string
+
+    end
+
+    def compile_match_operator(input_string)
+
+      rejection_exp = /( aannddy | orriioo |nnoottyy )/
+
+      if input_string.include?("=~")
+
+        input_string = input_string.gsub(" && "," aannddy ").gsub(" || "," orriioo ").gsub("!","nnoottyy")
+
+        left, right = input_string.split("=~")
+
+        if left.index(rejection_exp) != nil
+
+          left = left[left.index(rejection_exp)..-1]
+
+        elsif left.index(/\(/)
+
+          left = left[left.index(/\(/)+1..-1]
+
+        end
+
+        if right.index(rejection_exp) != nil
+
+          right = right[0...right.index(rejection_exp)]
+
+        elsif right.index(/\)/)
+
+          right = right[0...right.index(/\)/)]
+
+        end
+
+        original_string = "#{left}=~#{right}"
+
+        replacement_string = "#{left.rstrip} = #{left.rstrip}.match(#{right.lstrip.rstrip})"
+
+        input_string = input_string.sub(original_string,replacement_string)
+
+        input_string = input_string.gsub(" aannddy "," && ").gsub(" orriioo "," || ").gsub("nnoottyy","!")
+
+      end
+
+      return input_string
+
+    end
+
+    input_file_contents = input_file_contents.collect { |element| element.sub("==", "===") }
+
+    input_file_contents = input_file_contents.collect { |element| element.sub("!=", "!==") }
+
+    input_file_contents = input_file_contents.collect { |element| element.sub("equequ", "==") }
+
+    input_file_contents = input_file_contents.collect { |element| element.sub("elsuf", "else if") }
+
+    input_file_contents = input_file_contents.collect { |element| compile_power_operator(element) }
+
+    input_file_contents = input_file_contents.collect {|element| compile_match_operator(element)}
+
+    input_file_contents = input_file_contents.collect {|element| element.gsub("_!;",";")}
+
+    return input_file_contents
+
+  end

data/lib/nilac/compile_parallel_assignment.rb

@@ -0,0 +1,103 @@
+require_relative 'replace_strings'
+
+require_relative 'read_file_line_by_line'
+  
+  def compile_parallel_assignment(input_file_contents, temporary_nila_file)
+
+    def arrayify_right_side(input_string)
+
+      modified_input_string = input_string.dup
+
+      input_string = replace_strings(input_string)
+
+      javascript_regexp = /(if |while |for |function |function\()/
+
+      if input_string.include?("=") and input_string.index(javascript_regexp) == nil and input_string.strip[0..3] != "_ref" and !input_string.split("=")[1].include?("[")
+
+        right_side = input_string.split("=")[1]
+
+        if right_side.include?(",")
+
+          splits = right_side.split(",")
+
+          replacement_string = []
+
+          splits.each do |str|
+
+            unless str.include?(")") and !str.include?("(")
+
+              replacement_string << str
+
+            else
+
+              replacement_string[-1] = replacement_string[-1]+ "," +str
+
+            end
+
+          end
+
+          replacement_string = " [#{replacement_string.join(",").strip}]\n"
+
+          modified_input_string = modified_input_string.sub(right_side,replacement_string)
+
+        end
+
+      end
+
+      return modified_input_string
+
+    end
+
+    input_file_contents = input_file_contents.collect {|element| arrayify_right_side(element)}
+
+    possible_variable_lines = input_file_contents.clone.reject { |element| !element.include? "=" }
+
+    possible_parallel_assignment = possible_variable_lines.reject { |element| !element.split("=")[0].include? "," }
+
+    parallel_assignment_index = []
+
+    possible_parallel_assignment.each do |statement|
+
+      location_array = input_file_contents.each_index.select { |index| input_file_contents[index] == statement }
+
+      parallel_assignment_index << location_array[0]
+
+    end
+
+    modified_file_contents = input_file_contents.dup
+
+    parallel_assignment_counter = 1
+
+    possible_parallel_assignment.each_with_index do |line, index|
+
+      line_split = line.split(" = ")
+
+      right_side_variables = line_split[0].split(",")
+
+      replacement_string = "_ref#{parallel_assignment_counter} = #{line_split[1]}\n\n"
+
+      variable_string = ""
+
+      right_side_variables.each_with_index do |variable, var_index|
+
+        variable_string = variable_string + variable.rstrip + " = _ref#{parallel_assignment_counter}[#{var_index}]\n\n"
+
+      end
+
+      replacement_string = replacement_string + variable_string
+
+      modified_file_contents[parallel_assignment_index[index]] = replacement_string
+
+    end
+
+    file_id = open(temporary_nila_file, 'w')
+
+    file_id.write(modified_file_contents.join)
+
+    file_id.close()
+
+    line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+
+    return line_by_line_contents
+
+  end

data/lib/nilac/compile_ruby_methods.rb

@@ -0,0 +1,58 @@
+  def compile_ruby_methods(input_file_contents)
+
+    # These are some interesting methods that we really miss in Javascript.
+    # So we have made these methods available
+
+    method_map_replacement = {
+
+        ".split" => ".split(\" \")",
+
+        ".join" => ".join()",
+
+        ".strip" => ".replace(/^\\s+|\\s+$/g,'')",
+
+        ".lstrip" => ".replace(/^\\s+/g,\"\")",
+
+        ".rstrip" => ".replace(/\\s+$/g,\"\")",
+
+        ".to_s" => ".toString()",
+
+        ".reverse" => ".reverse()",
+
+        ".empty?" => ".length == 0",
+
+        ".upcase" => ".toUpperCase()",
+
+        ".downcase" => ".toLowerCase()",
+
+    }
+
+    method_map = method_map_replacement.keys
+
+    method_map_regex = method_map.collect {|name| name.gsub(".","\\.")}
+
+    method_map_regex = Regexp.new(method_map_regex.join("|"))
+
+    modified_file_contents = input_file_contents.clone
+
+    input_file_contents.each_with_index do |line, index|
+
+      if line.match(method_map_regex)
+
+        method_match = line.match(method_map_regex).to_a[0]
+
+        unless line.include?(method_match + "(")
+
+          line = line.sub(method_match,method_map_replacement[method_match])
+
+        end
+
+      end
+
+      modified_file_contents[index] = line
+
+    end
+
+    return modified_file_contents
+
+  end

data/lib/nilac/compile_special_keywords.rb

@@ -0,0 +1,44 @@
+require_relative 'replace_strings'
+  
+  def compile_special_keywords(input_file_contents)
+
+    # This method compiles some Ruby specific keywords to Javascript to make it easy to port
+    # Ruby code into Javascript
+    
+    keyword_replacement_map = {
+
+        "nil" => "null",
+
+        "Array.new" => "new Array()"
+
+    }
+
+    special_keywords = keyword_replacement_map.keys
+
+    keyword_map_regex = special_keywords.collect {|name| name.gsub(".","\\.")}
+
+    keyword_map_regex = Regexp.new(keyword_map_regex.join("|"))
+
+    modified_file_contents = input_file_contents.clone
+
+    input_file_contents.each_with_index do |line, index|
+
+      if replace_strings(line).match(keyword_map_regex)
+
+        method_match = line.match(keyword_map_regex).to_a[0]
+
+        if line.split(keyword_map_regex)[0].include?("=")
+
+          line = line.sub(method_match,keyword_replacement_map[method_match])
+
+        end
+
+      end
+
+      modified_file_contents[index] = line
+
+    end
+
+    return modified_file_contents
+
+  end

data/lib/nilac/compile_strings.rb

@@ -0,0 +1,145 @@
+def compile_strings(input_file_contents)
+
+  def compile_small_q_syntax(input_file_contents)
+
+    possible_syntax_usage = input_file_contents.reject { |element| !element.include?("%q") }
+
+    possible_syntax_usage.each do |line|
+
+      modified_line = line.dup
+
+      line_split = line.split("+").collect { |element| element.lstrip.rstrip }
+
+      line_split.each do |str|
+
+        delimiter = str[str.index("%q")+2]
+
+        string_extract = str[str.index("%q")..-1]
+
+        delimiter = "}" if delimiter.eql?("{")
+
+        delimiter = ")" if delimiter.eql?("(")
+
+        delimiter = ">" if delimiter.eql?("<")
+
+        if string_extract[-1].eql?(delimiter)
+
+          input_file_contents[input_file_contents.index(modified_line)] = input_file_contents[input_file_contents.index(modified_line)].sub(string_extract, "'#{string_extract[3...-1]}'")
+
+          modified_line = modified_line.sub(string_extract, "'#{string_extract[3...-1]}'")
+
+        elsif delimiter.eql?(" ")
+
+          input_file_contents[input_file_contents.index(modified_line)] = input_file_contents[input_file_contents.index(modified_line)].sub(string_extract, "'#{string_extract[3..-1]}'")
+
+          modified_line = modified_line.sub(string_extract, "'#{string_extract[3..-1]}'")
+
+        end
+
+      end
+
+    end
+
+    return input_file_contents
+
+  end
+
+  def compile_big_q_syntax(input_file_contents)
+
+    possible_syntax_usage = input_file_contents.reject { |element| !element.include?("%Q") }
+
+    possible_syntax_usage.each do |line|
+
+      modified_line = line.dup
+
+      line_split = line.split("+").collect { |element| element.lstrip.rstrip }
+
+      line_split.each do |str|
+
+        delimiter = str[str.index("%Q")+2]
+
+        string_extract = str[str.index("%Q")..-1]
+
+        delimiter = "}" if delimiter.eql?("{")
+
+        delimiter = ")" if delimiter.eql?("(")
+
+        delimiter = ">" if delimiter.eql?("<")
+
+        if string_extract[-1].eql?(delimiter)
+
+          input_file_contents[input_file_contents.index(modified_line)] = input_file_contents[input_file_contents.index(modified_line)].sub(string_extract, "\"#{string_extract[3...-1]}\"")
+
+          modified_line = modified_line.sub(string_extract, "\"#{string_extract[3...-1]}\"")
+
+        elsif delimiter.eql?(" ")
+
+          input_file_contents[input_file_contents.index(modified_line)] = input_file_contents[input_file_contents.index(modified_line)].sub(string_extract, "\"#{string_extract[3..-1]}\"")
+
+          modified_line = modified_line.sub(string_extract, "\"#{string_extract[3..-1]}\"")
+
+        end
+
+      end
+
+    end
+
+    return input_file_contents
+
+  end
+
+  def compile_percentage_syntax(input_file_contents)
+
+    possible_syntax_usage = input_file_contents.reject { |element| !element.include?("%") }
+
+    possible_syntax_usage = possible_syntax_usage.reject { |element| element.index(/(\%(\W|\s)\w{1,})/).nil? }
+
+    possible_syntax_usage.each do |line|
+
+      modified_line = line.dup
+
+      line_split = line.split("+").collect { |element| element.lstrip.rstrip }
+
+      line_split.each do |str|
+
+        delimiter = str[str.index("%")+1]
+
+        string_extract = str[str.index("%")..-1]
+
+        delimiter = "}" if delimiter.eql?("{")
+
+        delimiter = ")" if delimiter.eql?("(")
+
+        delimiter = ">" if delimiter.eql?("<")
+
+        if string_extract[-1].eql?(delimiter)
+
+          input_file_contents[input_file_contents.index(modified_line)] = input_file_contents[input_file_contents.index(modified_line)].sub(string_extract, "\"#{string_extract[2...-1]}\"")
+
+          modified_line = modified_line.sub(string_extract, "\"#{string_extract[2...-1]}\"")
+
+        elsif delimiter.eql?(" ")
+
+          input_file_contents[input_file_contents.index(modified_line)] = input_file_contents[input_file_contents.index(modified_line)].sub(string_extract, "\"#{string_extract[2..-1]}\"")
+
+          modified_line = modified_line.sub(string_extract, "\"#{string_extract[2..-1]}\"")
+
+        end
+
+      end
+
+    end
+
+    return input_file_contents
+
+  end
+
+  file_contents = compile_small_q_syntax(input_file_contents)
+
+  file_contents = compile_big_q_syntax(file_contents)
+
+  file_contents = compile_percentage_syntax(file_contents)
+
+  return file_contents
+
+end

data/lib/nilac/compile_whitespace_delimited_functions.rb

@@ -0,0 +1,97 @@
+require_relative 'read_file_line_by_line'
+  
+  def compile_whitespace_delimited_functions(input_file_contents, function_names, temporary_nila_file)
+
+    def extract(input_string, pattern_start, pattern_end)
+
+      def find_all_matching_indices(input_string, pattern)
+
+        locations = []
+
+        index = input_string.index(pattern)
+
+        while index != nil
+
+          locations << index
+
+          index = input_string.index(pattern, index+1)
+
+
+        end
+
+        return locations
+
+
+      end
+
+      all_start_locations = find_all_matching_indices(input_string, pattern_start)
+
+      pattern = []
+
+      all_start_locations.each do |location|
+
+        extracted_string = input_string[location..-1]
+
+        string_extract = extracted_string[0..extracted_string.index(pattern_end)]
+
+        if !string_extract.include?(" = function(")
+
+          pattern << string_extract
+
+        end
+
+      end
+
+      return pattern
+
+    end
+
+    begin
+
+      input_file_contents[-1] = input_file_contents[-1] + "\n" if !input_file_contents[-1].include?("\n")
+
+      joined_file_contents = input_file_contents.join
+
+      function_names.each do |list_of_functions|
+
+        list_of_functions.each do |function|
+
+          matching_strings = extract(joined_file_contents, function+" ", "\n")
+
+          matching_strings.each do |string|
+
+            modified_string = string.dup
+
+            modified_string = modified_string.rstrip + modified_string.split(modified_string.rstrip)[1].gsub(" ", "")
+
+            modified_string = modified_string.sub(function+" ", function+"(")
+
+            modified_string = modified_string.split("#{function}(")[0] + "#{function}(" + modified_string.split("#{function}(")[1].lstrip
+
+            modified_string = modified_string.sub("\n", ")\n")
+
+            joined_file_contents = joined_file_contents.sub(string, modified_string)
+
+          end
+
+        end
+
+      end
+
+    rescue NoMethodError
+
+      puts "Whitespace delimitation exited with errors!"
+
+    end
+
+    file_id = open(temporary_nila_file, 'w')
+
+    file_id.write(joined_file_contents)
+
+    file_id.close()
+
+    line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+
+    return line_by_line_contents
+
+  end

data/lib/nilac/create_mac_executable.rb

@@ -0,0 +1,25 @@
+def create_mac_executable(input_file)
+
+  def read_file_line_by_line(input_path)
+
+    file_id = open(input_path)
+
+    file_line_by_line = file_id.readlines()
+
+    file_id.close
+
+    return file_line_by_line
+
+  end
+
+  mac_file_contents = ["#!/usr/bin/env ruby\n\n"] + read_file_line_by_line(input_file)
+
+  mac_file_path = input_file.sub(".rb", "")
+
+  file_id = open(mac_file_path, "w")
+
+  file_id.write(mac_file_contents.join)
+
+  file_id.close
+
+end

data/lib/nilac/extract_parsable_file.rb

@@ -0,0 +1,23 @@
+def extract_parsable_file(input_file_contents)
+
+  reversed_file_contents = input_file_contents.reverse
+
+  line_counter = 0
+
+  if input_file_contents.join.include?("__END__")
+
+    while !reversed_file_contents[line_counter].strip.include?("__END__")
+
+      line_counter += 1
+
+    end
+
+    return_contents = input_file_contents[0...-1*line_counter-1]
+
+  else
+
+    input_file_contents
+
+  end
+
+end

data/lib/nilac/find_all_matching_indices.rb

@@ -0,0 +1,18 @@
+  def find_all_matching_indices(input_string, pattern)
+
+    locations = []
+
+    index = input_string.index(pattern)
+
+    while index != nil
+
+      locations << index
+
+      index = input_string.index(pattern, index+1)
+
+
+    end
+
+    return locations
+
+  end

data/lib/nilac/find_file_name.rb

@@ -0,0 +1,13 @@
+  def find_file_name(input_path, file_extension)
+
+    extension_remover = input_path.split(file_extension)
+
+    remaining_string = extension_remover[0].reverse
+
+    path_finder = remaining_string.index("/")
+
+    remaining_string = remaining_string.reverse
+
+    return remaining_string[remaining_string.length-path_finder..-1]
+
+  end

data/lib/nilac/find_file_path.rb

@@ -0,0 +1,13 @@
+def find_file_path(input_path, file_extension)
+
+  extension_remover = input_path.split(file_extension)
+
+  remaining_string = extension_remover[0].reverse
+
+  path_finder = remaining_string.index("/")
+
+  remaining_string = remaining_string.reverse
+
+  return remaining_string[0...remaining_string.length-path_finder]
+
+end