nilac 0.0.4.3.9.6 → 0.0.4.3.9.7

data/lib/nilac/pretty_print_javascript.rb

@@ -1,6 +1,6 @@
 require_relative 'find_all_matching_indices'
-
 require_relative 'read_file_line_by_line'
+require_relative 'replace_strings'
   
   def pretty_print_javascript(javascript_file_contents, temporary_nila_file,declarable_variables)
 
@@ -42,105 +42,93 @@ require_relative 'read_file_line_by_line'
 
     end
 
-    def fix_newlines(file_contents)
+    def fix_newlines(file_contents,main_block_numbers)
 
-      def extract_blocks(file_contents)
+      def block_compactor(input_block)
 
-        javascript_regexp = /(if |for |while |case |default:|switch\(|\(function\(|= function\(|,\s*function\(|((=|:)\s+\{))/
+        modified_block = input_block.reject {|element| element.strip.eql?("")}
 
-        block_starting_lines = file_contents.dup.reject { |element| element.index(javascript_regexp).nil? }[1..-1]
+        modified_block = modified_block.collect {|element| element.rstrip + "\n"}
 
-        block_starting_lines = block_starting_lines.reject { |element| element.include?("    ") }
+        return modified_block
 
-        initial_starting_lines = block_starting_lines.dup
+      end
 
-        starting_line_indices = []
+      main_block_numbers = [ ] if main_block_numbers.nil?
 
-        block_starting_lines.each do |line|
+      unless main_block_numbers.empty?
 
-          starting_line_indices << file_contents.index(line)
+        javascript_regexp = /(if |for |while |case |default:|switch\(|,function\(|\(function\(|= function\(|((=|:)\s+\{))/
 
-        end
+        starting_locations = []
 
-        block_ending_lines = file_contents.dup.each_index.select { |index| (file_contents[index].eql? "  }\n" or file_contents[index].eql? "  };\n" or file_contents[index].lstrip.eql?("});\n"))}
+        file_contents.each_with_index do |line, index|
 
-        block_ending_lines = block_ending_lines.reject {|index| file_contents[index].include?("    ")}
+          if line.index(javascript_regexp) != nil
 
-        modified_file_contents = file_contents.dup
+            starting_locations << index
 
-        code_blocks = []
-
-        starting_index = starting_line_indices[0]
+          end
 
-        begin
+        end
 
-          for x in 0...initial_starting_lines.length
+        remaining_contents, blocks = roll_blocks(file_contents,starting_locations)
 
-            code_blocks << modified_file_contents[starting_index..block_ending_lines[0]]
+        modified_block = []
 
-            modified_file_contents[starting_index..block_ending_lines[0]] = []
+        blocks.each do |block|
 
-            modified_file_contents.insert(starting_index, "  *****")
+          while block.join.include?("--block")
 
-            block_starting_lines = modified_file_contents.dup.reject { |element| element.index(javascript_regexp).nil? }[1..-1]
+            nested_blocks = block.reject {|element| !replace_strings(element).include?("--block")}
 
-            block_starting_lines = block_starting_lines.reject { |element| element.include?("    ") }
+            block_numbers = nested_blocks.collect {|element| element.strip.split("--block")[1].to_i}
 
-            starting_line_indices = []
+            block_numbers.each_with_index do |number,index|
 
-            block_starting_lines.each do |line|
+              location = block.index(nested_blocks[index])
 
-              starting_line_indices << modified_file_contents.index(line)
+              block[location] = blocks[number]
 
             end
 
-            block_ending_lines = modified_file_contents.dup.each_index.select { |index| (modified_file_contents[index].eql? "  }\n" or modified_file_contents[index].eql? "  };\n" or modified_file_contents[index].lstrip.eql?("});\n")) }
-
-            starting_index = starting_line_indices[0]
+            block = block.flatten
 
           end
 
-        #rescue TypeError
-        ##
-        #  puts "Whitespace was left unfixed!"
-        ##
-        #rescue ArgumentError
-        ##
-        #  puts "Whitespace was left unfixed!"
+          modified_block << block
 
         end
 
-        return modified_file_contents, code_blocks
-
-      end
-
-      compact_contents = file_contents.reject { |element| element.lstrip.eql? "" }
+        main_block_numbers = main_block_numbers.collect {|element| element.strip.to_i}
 
-      compact_contents, code_blocks = extract_blocks(compact_contents)
+        remaining_contents = remaining_contents.reject {|element| element.strip.eql?("")}
 
-      processed_contents = compact_contents[1...-1].collect { |line| line+"\n" }
+        remaining_contents = [remaining_contents[0]] + remaining_contents[1...-1].collect {|element| element + "\n"} + [remaining_contents[-1]]
 
-      compact_contents = [compact_contents[0]] + processed_contents + [compact_contents[-1]]
+        main_block_numbers.each do |number|
 
-      code_block_locations = compact_contents.each_index.select { |index| compact_contents[index].eql? "  *****\n" }
+          correct_block = block_compactor(modified_block[number])
 
-      initial_locations = code_block_locations.dup
+          correct_block << "\n"
 
-      starting_index = code_block_locations[0]
+          remaining_contents[remaining_contents.index("--block#{number}\n\n")] = correct_block
 
-      for x in 0...initial_locations.length
+        end
 
-        code_blocks[x][-1] = code_blocks[x][-1] + "\n"
+        remaining_contents = remaining_contents.flatten
 
-        compact_contents = compact_contents[0...starting_index] + code_blocks[x] + compact_contents[starting_index+1..-1]
+      else
 
-        code_block_locations = compact_contents.each_index.select { |index| compact_contents[index].eql? "  *****\n" }
+        remaining_contents = block_compactor(file_contents)
 
-        starting_index = code_block_locations[0]
+        remaining_contents = [remaining_contents[0]] + remaining_contents[1...-1].collect {|element| element + "\n"} + [remaining_contents[-1]]
 
       end
 
-      return compact_contents
+      remaining_contents[-1] = remaining_contents[-1].rstrip
+
+      return remaining_contents
 
     end
 
@@ -176,7 +164,7 @@ require_relative 'read_file_line_by_line'
 
         current_block = []
 
-        possible_blocks.each_with_index do |block|
+        possible_blocks.each do |block|
 
           if !block[0].eql?(current_block[-1])
 
@@ -190,7 +178,7 @@ require_relative 'read_file_line_by_line'
 
           current_block.each_with_index do |line, index|
 
-            if line.lstrip.eql? "}\n" or line.lstrip.eql?("};\n") or line.lstrip.include?("_!;\n") or line.lstrip.include?("});\n")
+            if line.strip.eql? "}" or line.strip.eql?("};") or line.strip.include?("_!;") or line.strip.eql?("});")
 
               end_counter += 1
 
@@ -234,7 +222,7 @@ require_relative 'read_file_line_by_line'
 
               current_block.each_with_index do |line, index|
 
-                if line.lstrip.eql? "}\n" or line.lstrip.eql?("};\n") or line.lstrip.include?("_!;\n") or line.lstrip.include?("});\n")
+                if line.strip.eql? "}" or line.strip.eql?("};") or line.strip.include?("_!;") or line.strip.eql?("});")
 
                   end_counter += 1
 
@@ -306,6 +294,8 @@ require_relative 'read_file_line_by_line'
 
     javascript_file_contents = javascript_file_contents.collect { |element| element.sub("whaaleskey", "while") }
 
+    javascript_file_contents = javascript_file_contents.collect { |element| element.sub("}#@$", "}") }
+
     javascript_file_contents = reset_tabs(javascript_file_contents)
 
     starting_locations = []
@@ -408,14 +398,16 @@ require_relative 'read_file_line_by_line'
 
       remaining_file_contents = ["(function() {\n", remaining_file_contents, "\n}).call(this);"].flatten
 
-      joined_file_contents = remaining_file_contents.join
-
       main_blocks.each_with_index do |block_id, index|
 
-        joined_file_contents = joined_file_contents.sub(block_id, modified_blocks[index])
+        remaining_file_contents[remaining_file_contents.index(block_id)] = modified_blocks[index]
 
       end
 
+      remaining_file_contents = remaining_file_contents.reject {|element| element.eql?("  ")}
+
+      joined_file_contents = remaining_file_contents.join
+
     else
 
       remaining_file_contents = remaining_file_contents.collect { |element| "  " + element }
@@ -436,7 +428,7 @@ require_relative 'read_file_line_by_line'
 
     line_by_line_contents = line_by_line_contents.collect {|element| element.gsub("%$%$ {","")}
 
-    line_by_line_contents = fix_newlines(line_by_line_contents)
+    line_by_line_contents = fix_newlines(line_by_line_contents,main_block_numbers)
 
     removable_indices = line_by_line_contents.each_index.select {|index| line_by_line_contents[index].strip == "%$%$;" }
 

data/lib/nilac/replace_multiline_comments.rb

@@ -1,7 +1,5 @@
   require_relative "find_file_name"
-	
 	require_relative "find_file_path"
-	
 	require_relative "read_file_line_by_line"
 	
 	def replace_multiline_comments(input_file_contents, nila_file_path, *output_js_file_path)
@@ -63,6 +61,12 @@
 
     temporary_nila_file = find_file_path(nila_file_path, ".nila") + "temp_nila.nila"
 
+    if File.exist?(temporary_nila_file)
+
+      File.delete(temporary_nila_file)
+
+    end
+
     if output_js_file_path.empty?
 
       output_js_file = find_file_path(nila_file_path, ".nila") + find_file_name(nila_file_path, ".nila") + ".js"

data/lib/nilac/replace_named_functions.rb

@@ -1,108 +1,81 @@
 require_relative 'read_file_line_by_line'
+require_relative 'rollblocks'
+require_relative 'replace_strings'
+
   
   def replace_named_functions(nila_file_contents, temporary_nila_file)
 
-    def extract_array(input_array, start_index, end_index)
-
-      return input_array[start_index..end_index]
-
-    end
+    final_modified_file_contents = nila_file_contents.clone
 
-    end_locations = []
+    joined_file_contents = final_modified_file_contents.join
 
-    key_word_locations = []
+    modified_file_contents = []
 
-    start_blocks = []
+    rand_number = []
 
-    end_blocks = []
+    nila_file_contents.each do |content|
 
-    nila_regexp = /(def )/
+      if replace_strings(content).include?("def ")
 
-    named_code_blocks = []
+        rand_num = rand(1..25)
 
-    for x in 0...nila_file_contents.length
+        while rand_number.include?(rand_num)
 
-      current_row = nila_file_contents[x]
+          rand_num = rand(1..10)
 
-      if current_row.index(nila_regexp) != nil
+        end
 
-        key_word_locations << x
+        modified_file_contents << content.sub("def ","#{" "*rand_num}def ")
 
-      elsif current_row.lstrip.eql?("end\n") || current_row.strip.eql?("end")
+        rand_number << rand_num
 
-        end_locations << x
+      else
 
+        modified_file_contents << content
 
       end
 
-
     end
 
-    unless key_word_locations.empty?
-
-      modified_file_contents = nila_file_contents.dup
-
-      for y in 0...end_locations.length
-
-        current_location = end_locations[y]
-
-        current_string = modified_file_contents[current_location]
-
-        finder_location = current_location
-
-        begin
-
-          while current_string.index(nila_regexp) == nil
-
-            finder_location -= 1
+    nila_file_contents = modified_file_contents.clone
 
-            current_string = modified_file_contents[finder_location]
+    possible_function_blocks = nila_file_contents.reject {|element| !replace_strings(element).include?("def ")}
 
-          end
+    function_block_locations = []
 
-          code_block_begin = finder_location
+    possible_function_blocks.each do |block_start|
 
-          code_block_end = current_location
+      function_block_locations << nila_file_contents.clone.each_index.select {|index| nila_file_contents[index] == block_start }
 
-          start_blocks << code_block_begin
-
-          end_blocks << code_block_end
-
-          code_block_begin_string_split = modified_file_contents[code_block_begin].split(" ")
-
-          code_block_begin_string_split[0] = code_block_begin_string_split[0].reverse
-
-          code_block_begin_string = code_block_begin_string_split.join(" ")
+    end
 
-          modified_file_contents[code_block_begin] = code_block_begin_string
+    function_block_locations = function_block_locations.flatten
 
-        rescue NoMethodError
-        
-          puts "Function compilation failed!"
+    function_block_locations = [0,function_block_locations,-1].flatten.uniq
 
-        end
+    file_remains, code_blocks = extract_blocks(function_block_locations,final_modified_file_contents)
 
-      end
+    modified_code_blocks = []
 
-      final_modified_file_contents = nila_file_contents.dup
+    code_blocks.each do |block|
 
-      joined_file_contents = final_modified_file_contents.join
+      modified_code_blocks << block.collect {|element| element.gsub("\n\t\nend\n\t\n","}#@$")}
 
-      while start_blocks.length != 0
+    end
 
-        top_most_level = start_blocks.min
+    code_blocks = modified_code_blocks.clone
 
-        top_most_level_index = start_blocks.index(top_most_level)
+    named_code_blocks = code_blocks.clone.reject {|element| !replace_strings(element[0]).include?("def ")}
 
-        matching_level = end_blocks[top_most_level_index]
+    modified_code_blocks = []
 
-        named_code_blocks << extract_array(final_modified_file_contents, top_most_level, matching_level)
+    code_blocks.each do |block|
 
-        start_blocks.delete_at(top_most_level_index)
+      modified_code_blocks << block.collect {|element| element.gsub("")}
 
-        end_blocks.delete(matching_level)
+    end
 
-      end
+    unless named_code_blocks.empty?
 
       codeblock_counter = 1
 
@@ -148,7 +121,10 @@ require_relative 'read_file_line_by_line'
 
     line_by_line_contents = read_file_line_by_line(temporary_nila_file)
 
-    return line_by_line_contents, named_functions, nested_functions
+    named_functions = named_functions.reject {|element| element.empty?}
+
+    nested_functions = nested_functions.reject {|element| element.empty?}
 
+    return line_by_line_contents, named_functions, nested_functions
 
   end

data/lib/nilac/replace_strings.rb

@@ -1,35 +1,58 @@
-    def replace_strings(input_string)
+# This is the simplest and most important method on the whole Nilac source code. This protects user written
+# strings from being overwritten during the compilation
 
-      string_counter = 0
+def replace_strings(input_string)
 
-      if input_string.count("\"") % 2 == 0
+  element = input_string.gsub("==", "equalequal")
 
-        while input_string.include?("\"")
+  element = element.gsub("!=", "notequal")
 
-        string_extract = input_string[input_string.index("\"")..input_string.index("\"",input_string.index("\"")+1)]
+  element = element.gsub("+=", "plusequal")
 
-        input_string = input_string.sub(string_extract,"--repstring#{string_counter}")
+  element = element.gsub("-=", "minusequal")
 
-        string_counter += 1
+  element = element.gsub("*=", "multiequal")
 
-        end
+  element = element.gsub("/=", "divequal")
 
-      end
+  element = element.gsub("%=", "modequal")
 
-      if input_string.count("'") % 2 == 0
+  element = element.gsub("=~", "matchequal")
 
-        while input_string.include?("'")
+  element = element.gsub(">=", "greatequal")
 
-          string_extract = input_string[input_string.index("'")..input_string.index("'",input_string.index("'")+1)]
+  input_string = element.gsub("<=", "lessyequal")
 
-          input_string = input_string.sub(string_extract,"--repstring#{string_counter}")
+  string_counter = 0
 
-          string_counter += 1
+  if input_string.count("\"") % 2 == 0
 
-        end
+    while input_string.include?("\"")
 
-      end
+    string_extract = input_string[input_string.index("\"")..input_string.index("\"",input_string.index("\"")+1)]
 
-      return input_string
+    input_string = input_string.sub(string_extract,"--repstring#{string_counter}")
+
+    string_counter += 1
+
+    end
+
+  end
+
+  if input_string.count("'") % 2 == 0
+
+    while input_string.include?("'")
+
+      string_extract = input_string[input_string.index("'")..input_string.index("'",input_string.index("'")+1)]
+
+      input_string = input_string.sub(string_extract,"--repstring#{string_counter}")
+
+      string_counter += 1
 
     end
+
+  end
+
+  return input_string
+
+end

data/lib/nilac/rollblocks.rb

@@ -1,16 +1,36 @@
-def extract_blocks(statement_indexes, input_file_contents)
+require_relative 'replace_strings'
 
-  possible_if_blocks = []
+def extract_blocks(statement_indexes, input_file_contents,options = [])
 
-  if_block_counter = 0
+  possible_blocks = []
+
+  block_counter = 0
 
   extracted_blocks = []
 
-  controlregexp = /(if |while |def | do )/
+  input_file_contents = input_file_contents.collect {|element| element.gsub("}#@$","\n\t\nend\n\t\n")}
+
+  input_file_contents = input_file_contents.collect {|element| element.gsub("};","\t\t}\n\t")} if options.length.eql?(5)
+
+  controlregexp = /(if |Euuf |while |for |def | do |class )/ if options.empty?
+
+  controlregexp = /(if |while |class |= function)/ if options.length.eql?(1)
+
+  controlregexp = /(if |while |def | do |class )/ if options.length.eql?(2)
+
+  controlregexp = /(Euuf |while |for | do |function )/ if options.length.eql?(5)
 
-  for x in 0...if_statement_indexes.length-1
+  endexpr = "end" if options.empty?
 
-    possible_if_blocks << input_file_contents[if_statement_indexes[x]..if_statement_indexes[x+1]]
+  endexpr = "};" if options.length.eql?(1)
+
+  endexpr = "end" if options.length.eql?(2)
+
+  endexpr = "}" if options.length.eql?(5)
+
+  for x in 0...statement_indexes.length-1
+
+    possible_blocks << input_file_contents[statement_indexes[x]..statement_indexes[x+1]]
 
   end
 
@@ -20,7 +40,7 @@ def extract_blocks(statement_indexes, input_file_contents)
 
   current_block = []
 
-  possible_if_blocks.each_with_index do |block|
+  possible_blocks.each_with_index do |block|
 
     unless current_block[-1] == block[0]
 
@@ -32,10 +52,9 @@ def extract_blocks(statement_indexes, input_file_contents)
 
     end
 
-
     current_block.each_with_index do |line, index|
 
-      if line.strip.eql? "end"
+      if line.strip.eql? endexpr
 
         end_counter += 1
 
@@ -55,7 +74,7 @@ def extract_blocks(statement_indexes, input_file_contents)
 
         array_extract.each_with_index do |line|
 
-          break if (line.lstrip.index(controlregexp) != nil and line.lstrip.index(rejectionregexp).nil?)
+          break if (line.lstrip.index(controlregexp) != nil)
 
           index_counter += 1
 
@@ -69,9 +88,9 @@ def extract_blocks(statement_indexes, input_file_contents)
 
         block_end = current_block.index(block_extract[-1])
 
-        current_block[block_start..block_end] = "--ifblock#{if_block_counter}"
+        current_block[block_start..block_end] = "--block#{block_counter}"
 
-        if_block_counter += 1
+        block_counter += 1
 
         end_counter = 0
 
@@ -79,7 +98,7 @@ def extract_blocks(statement_indexes, input_file_contents)
 
         current_block.each_with_index do |line, index|
 
-          if line.strip.eql? "end"
+          if line.strip.eql? endexpr
 
             end_counter += 1
 
@@ -95,6 +114,60 @@ def extract_blocks(statement_indexes, input_file_contents)
 
   end
 
+  modified_blocks = extracted_blocks.clone
+
+  modified_blocks.each_with_index do |block,index|
+
+    extracted_blocks[index] = block.collect {|element| element.gsub("\n\t\nend\n\t\n","}#@$")}
+
+    extracted_blocks[index] = block.collect {|element| element.gsub("\t\t}\n\t","};")}
+
+  end
+
+  if options.length == 5
+
+    output_blocks = extracted_blocks
+
+    main_block = extracted_blocks.reject {|element| !replace_strings(element[0]).index(/function /)}
+
+    return main_block.flatten,output_blocks
+
+  else
+
+  modified_rolled_blocks = []
+
+  rolled_blocks = extracted_blocks.reject {|element| !replace_strings(element.join).include?("--block")}
+
+  rolled_blocks.each do |block|
+
+    included_blocks = block.reject {|element| !replace_strings(element).include?("--block")}
+
+    matching_blocks = included_blocks.collect {|element| element.split("--block")[1].to_i}
+
+    while block.join.include?("--block")
+
+      block[block.index(included_blocks[0])] = extracted_blocks[matching_blocks[0]]
+
+      included_blocks.delete_at(0)
+
+      matching_blocks.delete_at(0)
+
+    end
+
+    modified_rolled_blocks << block
+
+  end
+
+  rolled_blocks.each_with_index do |block,index|
+
+    extracted_blocks[extracted_blocks.index(block)] = modified_rolled_blocks[index]
+
+  end
+
+  extracted_blocks = extracted_blocks.collect {|element| element.flatten}
+
   return current_block, extracted_blocks
 
+  end
+
 end

data/lib/nilac/version.rb

@@ -1,3 +1,3 @@
 module Nilac
-  VERSION = "0.0.4.3.9.6"
+  VERSION = "0.0.4.3.9.7"
 end