nilac 0.0.4.3.9.2 → 0.0.4.3.9.3

data/lib/nilac/compile_custom_function_map.rb

@@ -0,0 +1,45 @@
+  def compile_custom_function_map(input_file_contents)
+
+    function_map_replacements = {
+
+        "puts" => "console.log",
+
+        "p" => "console.log",
+
+        "print" => "process.stdout.write",
+
+    }
+
+    function_map = function_map_replacements.keys
+
+    modified_file_contents = input_file_contents.dup
+
+    javascript_regexp = /(if |for |while |\(function\(|= function\(|((=|:)\s+\{))/
+
+    input_file_contents.each_with_index do |line, index|
+
+      function_map.each do |function|
+
+        if line.include?(function+"(") or line.include?(function+" ") and line.index(javascript_regexp) == nil
+
+          testsplit =  line.split(function)
+
+          testsplit = testsplit.collect {|element| element.strip}
+
+          testsplit[0] = " " if testsplit[0].eql?("")
+
+          if testsplit[0][-1].eql?(" ") or testsplit[0].eql?("return")
+
+            modified_file_contents[index] = line.sub(function, function_map_replacements[function])
+
+          end
+
+        end
+
+      end
+
+    end
+
+    return modified_file_contents, function_map_replacements.values
+
+  end

data/lib/nilac/compile_default_values.rb

@@ -0,0 +1,160 @@
+  require_relative 'ErrorDeclarations'
+	
+	require_relative 'read_file_line_by_line'
+	
+	def compile_default_values(input_file_contents, temporary_nila_file)
+
+    #This method compiles default values present in functions. An example is provided below
+
+    # def fill(container = "cup",liquid = "coffee")
+    #   puts "Filling the #{container} with #{liquid}"
+    # end
+
+    def errorFree(function_params)
+
+      # This method checks for use cases in complex arguments where a default argument is used
+      # after an optional argument. This will result in erroneous output. So this method will
+      # stop it from happening.
+
+      # Example:
+      # def method_name(a,b,*c,d = 1,c,e)
+
+      optional_param = function_params.reject {|element| !replace_strings(element).include?("*")}[0]
+
+      unless optional_param.nil?
+
+        after_splat = function_params[function_params.index(optional_param)+1..-1]
+
+        if after_splat.reject {|element| !element.include?("=")}.empty?
+
+          true
+
+        else
+
+          NilaSyntaxError.new("You cannot have default argument after an optional argument! Change the following usage!\n#{function_params.join(",")}")
+
+        end
+
+      else
+
+        true
+
+      end
+
+    end
+
+    def parse_default_values(input_function_definition)
+
+      split1, split2 = input_function_definition.split("(")
+
+      split2, split3 = split2.split(")")
+
+      function_parameters = split2.split(",")
+
+      if errorFree(function_parameters)
+
+        default_value_parameters = function_parameters.reject { |element| !element.include? "=" }
+
+        replacement_parameters = []
+
+        replacement_string = ""
+
+        default_value_parameters.each do |paramvalue|
+
+          param, value = paramvalue.split("=")
+
+          replacement_parameters << param.lstrip.rstrip
+
+          replacement_string = replacement_string + "\n" + "if (#{param.lstrip.rstrip} equequ null) {\n  #{paramvalue.lstrip.rstrip}\n}\n" +"\n"
+
+        end
+
+        return replacement_string, default_value_parameters, replacement_parameters
+
+      end
+
+    end
+
+    reject_regexp = /(function |Euuf |if |else|elsuf|switch |case|while |whaaleskey |for )/
+
+    input_file_contents = input_file_contents.collect { |element| element.gsub("==", "equalequal") }
+
+    input_file_contents = input_file_contents.collect { |element| element.gsub("!=", "notequal") }
+
+    input_file_contents = input_file_contents.collect { |element| element.gsub("+=", "plusequal") }
+
+    input_file_contents = input_file_contents.collect { |element| element.gsub("-=", "minusequal") }
+
+    input_file_contents = input_file_contents.collect { |element| element.gsub("*=", "multiequal") }
+
+    input_file_contents = input_file_contents.collect { |element| element.gsub("/=", "divequal") }
+
+    input_file_contents = input_file_contents.collect { |element| element.gsub("%=", "modequal") }
+
+    input_file_contents = input_file_contents.collect { |element| element.gsub("=~", "matchequal") }
+
+    input_file_contents = input_file_contents.collect { |element| element.gsub(">=", "greatequal") }
+
+    input_file_contents = input_file_contents.collect { |element| element.gsub("<=", "lessyequal") }
+
+    possible_default_values = input_file_contents.dup.reject { |element| (!element.include?("def")) }
+
+    possible_default_values = possible_default_values.reject { |element| !element.include?("=") }
+
+    possible_default_values = possible_default_values.reject {|element| !element.index(reject_regexp) == nil}
+
+    if !possible_default_values.empty?
+
+      possible_default_values.each do |line|
+
+        current_line_index = input_file_contents.each_index.select { |index| input_file_contents[index] == line }.flatten[0]
+
+        replacement_string, value_parameters, replacement_parameters = parse_default_values(line)
+
+        modified_line = line.dup
+
+        value_parameters.each_with_index do |val, index|
+
+          modified_line = modified_line.sub(val, replacement_parameters[index])
+
+        end
+
+        input_file_contents[current_line_index] = modified_line
+
+        input_file_contents.insert(current_line_index+1,replacement_string)
+
+      end
+
+    end
+
+    file_id = open(temporary_nila_file, 'w')
+
+    file_id.write(input_file_contents.join)
+
+    file_id.close()
+
+    line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+
+    line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("plusequal", "+=") }
+
+    line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("minusequal", "-=") }
+
+    line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("multiequal", "*=") }
+
+    line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("divequal", "/=") }
+
+    line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("modequal", "%=") }
+
+    line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("equalequal", "==") }
+
+    line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("notequal", "!=") }
+
+    line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("matchequal", "=~") }
+
+    line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("greatequal", ">=") }
+
+    line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("lessyequal", "<=") }
+
+    return line_by_line_contents
+
+  end

data/lib/nilac/compile_hashes.rb

@@ -0,0 +1,123 @@
+require_relative 'replace_strings'
+
+require_relative 'read_file_line_by_line'
+  
+  def compile_hashes(input_file_contents,temporary_nila_file)
+
+    def compile_multiline_hashes(input_file_contents,temporary_nila_file)
+      
+      javascript_regexp = /(if |while |for |function |function\()/
+
+      modified_file_contents = input_file_contents.clone
+
+      input_file_contents = input_file_contents.collect {|line| replace_strings(line)}
+
+      possible_hashes = input_file_contents.reject { |element| !element.include?("{") }
+
+      possible_multiline_hashes = possible_hashes.reject { |element| element.include?("}") }
+
+      possible_multiline_hashes = possible_multiline_hashes.reject {|element| element.index(javascript_regexp) != nil}
+
+      multiline_hashes = []
+
+      possible_multiline_hashes.each do |starting_line|
+
+        index = input_file_contents.index(starting_line)
+
+        line = modified_file_contents[index]
+
+        until line.include?("}\n")
+
+          index += 1
+
+          line = modified_file_contents[index]
+
+        end
+
+        multiline_hashes << modified_file_contents[input_file_contents.index(starting_line)..index]
+
+      end
+
+      joined_file_contents = modified_file_contents.join
+
+      multiline_hashes.each do |hash|
+
+        modified_hash = hash.join
+
+        hash_extract = modified_hash[modified_hash.index("{")..modified_hash.index("}")]
+
+        hash_contents = hash_extract.split("{")[1].split("}")[0].lstrip.rstrip.split(",").collect { |element| element.lstrip.rstrip }
+
+        hash_contents = "{" + hash_contents.join(",") + "}"
+
+        joined_file_contents = joined_file_contents.sub(hash_extract, hash_contents)
+
+      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
+
+    def compile_inline_hashes(input_file_contents)
+
+      javascript_regexp = /(if |while |for |function |function\(|%[qQw]*\{)/
+
+      modified_file_contents = input_file_contents.clone.collect {|element| replace_strings(element)}
+
+      possible_inline_hashes = modified_file_contents.reject {|element| element.count("{") != 1}
+
+      possible_inline_hashes = possible_inline_hashes.reject {|element| element.count("}") != 1}
+
+      possible_inline_hashes = possible_inline_hashes.reject {|element| element.index(javascript_regexp) != nil}
+
+      possible_inline_hashes = possible_inline_hashes.reject {|element| element.include?("{}")}
+
+      possible_inline_hashes.each do |hash|
+
+        hash = input_file_contents[modified_file_contents.index(hash)]
+
+        hash_extract = hash[hash.index("{")..hash.index("}")]
+
+        contents = hash_extract[1...-1].split(",")
+
+        hash_contents = []
+
+        contents.each do |items|
+
+          items = items.lstrip.sub(":","") if items.lstrip[0] == ":"
+
+          key, value = items.split("=>").collect {|element| element.lstrip.rstrip} if items.include?("=>")
+
+          key, value = items.split(":").collect {|element| element.lstrip.rstrip} if items.include?(":")
+
+          key = key.gsub("'","").gsub("\"","")
+
+          hash_contents << "  #{key}: #{value},"
+
+        end
+
+        replacement_string = "{\n" + hash_contents.join("\n") + "\n};\n"
+
+        input_file_contents[input_file_contents.index(hash)] = input_file_contents[input_file_contents.index(hash)].sub(hash_extract,replacement_string)
+
+      end
+
+      return input_file_contents
+
+    end
+
+    file_contents = compile_multiline_hashes(input_file_contents,temporary_nila_file)
+
+    file_contents = compile_inline_hashes(file_contents)
+
+    return file_contents
+
+  end

data/lib/nilac/compile_heredocs.rb

@@ -0,0 +1,62 @@
+require_relative 'read_file_line_by_line'
+  
+  def compile_heredocs(input_file_contents, temporary_nila_file)
+
+    joined_file_contents = input_file_contents.join
+
+    possible_heredocs = input_file_contents.reject { |element| !element.include?("<<-") }
+
+    possible_heredocs = possible_heredocs.collect { |element| element.match(/<<-(.*|\w*)/).to_a[0] }
+
+    possible_heredocs.each do |heredoc|
+
+      delimiter = heredoc[3..-1]
+
+      quote = 2
+
+      if delimiter.include?("'")
+
+        quote = 1
+
+      end
+
+      delimiter = delimiter.gsub("\"", "") if quote == 2
+
+      delimiter = delimiter.gsub("'", "") if quote == 1
+
+      string_split = joined_file_contents.split(heredoc, 2)
+
+      string_extract = string_split[1]
+
+      heredoc_extract = string_extract[0...string_extract.index(delimiter)]
+
+      replacement_string = ""
+
+      if quote == 1
+
+        replacement_string = "'#{heredoc_extract.delete("\"")}'".lstrip.inspect
+
+        replacement_string = replacement_string[1..-2]
+
+      elsif quote == 2
+
+        replacement_string = heredoc_extract.lstrip.inspect
+
+      end
+
+      joined_file_contents = joined_file_contents.sub(heredoc + heredoc_extract + delimiter, replacement_string)
+
+    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/compile_integers.rb

@@ -0,0 +1,23 @@
+  def compile_integers(input_file_contents)
+
+    modified_file_contents = input_file_contents.clone
+
+    input_file_contents.each_with_index do |line,index|
+
+      matches = line.scan(/(([0-9]+_)+([0-9]+|$))/)
+
+      unless matches.empty?
+
+        matches.each do |match_arr|
+
+            modified_file_contents[index] = modified_file_contents[index].sub(match_arr[0],match_arr[0].gsub("_",""))
+
+        end
+
+      end
+
+    end
+
+    return modified_file_contents
+
+  end

data/lib/nilac/compile_interpolated_strings.rb

@@ -0,0 +1,133 @@
+require_relative 'find_all_matching_indices'
+  
+  def compile_interpolated_strings(input_file_contents)
+
+    modified_file_contents = input_file_contents.dup
+
+    single_quoted_strings = input_file_contents.reject { |element| !(element.count("'") >= 2) }
+
+    single_quoted_strings.each do |str|
+
+      modified_string = str.dup
+
+      while modified_string.include?("'")
+
+        first_index = modified_string.index("'")
+
+        string_extract = modified_string[first_index..modified_string.index("'", first_index+1)]
+
+        modified_string = modified_string.sub(string_extract, "--single_quoted")
+
+      end
+
+      input_file_contents[input_file_contents.index(str)] = modified_string
+
+    end
+
+    input_file_contents.each_with_index do |line, index|
+
+      if line.include?("\#{")
+
+        modified_line = line.dup
+
+        interpol_starting_loc = find_all_matching_indices(modified_line, "\#{") + [-1]
+
+        interpolated_strings = []
+
+        until interpol_starting_loc.empty?
+
+          interpol_starting_loc[1] = -2 if interpol_starting_loc[1] == -1
+
+          string_extract = modified_line[interpol_starting_loc[0]+1..interpol_starting_loc[1]+1]
+
+          closed_curly_brace_index = find_all_matching_indices(string_extract, "}")
+
+          index_counter = 0
+
+          test_string = ""
+
+          until closed_curly_brace_index.empty?
+
+            test_string = string_extract[0..closed_curly_brace_index[0]]
+
+            original_string = test_string.dup
+
+            if test_string.include?("{")
+
+              test_string = test_string.reverse.sub("{", "$#{index_counter}$").reverse
+
+              test_string[-1] = "@#{index_counter}@"
+
+            end
+
+            string_extract = string_extract.sub(original_string, test_string)
+
+            closed_curly_brace_index = find_all_matching_indices(string_extract, "}")
+
+            index_counter += 1
+
+          end
+
+          string_extract = string_extract[0..string_extract.length-string_extract.reverse.index(/@\d@/)]
+
+          interpolated_string = "\#{" + string_extract.split("@#{index_counter-1}@")[0].split("$#{index_counter-1}$")[1] + "}"
+
+          to_be_replaced = interpolated_string.scan(/\$\d\$/)
+
+          closing_brace_rep = interpolated_string.scan(/@\d@/)
+
+          to_be_replaced.each_with_index do |rep, index|
+
+            interpolated_string = interpolated_string.sub(rep, "{").sub(closing_brace_rep[index], "}")
+
+          end
+
+          interpolated_strings << interpolated_string
+
+          modified_line = modified_line.sub(interpolated_string, "--interpolate")
+
+          if find_all_matching_indices(modified_line, "\#{").empty?
+
+            interpol_starting_loc = []
+
+          else
+
+            interpol_starting_loc = find_all_matching_indices(modified_line, "\#{") + [-1]
+
+          end
+
+        end
+
+        interpolated_strings.each do |interpol|
+
+          string_split = line.split(interpol)
+
+          if string_split[1].eql?("\"\n")
+
+            replacement_string = "\" + " + "(#{interpol[2...-1]})"
+
+            modified_file_contents[index] = modified_file_contents[index].sub(interpol+"\"", replacement_string)
+
+          elsif string_split[1].eql?("\")\n")
+
+            replacement_string = "\" + " + "(#{interpol[2...-1]})"
+
+            modified_file_contents[index] = modified_file_contents[index].sub(interpol + "\"", replacement_string)
+
+          else
+
+            replacement_string = "\"" + " + " + "(#{interpol[2...-1]})" + " + \""
+
+            modified_file_contents[index] = modified_file_contents[index].sub(interpol, replacement_string)
+
+          end
+
+        end
+
+      end
+
+    end
+
+    return modified_file_contents
+
+  end