nilac 0.0.4.3.4 → 0.0.4.3.6

data/src/nilac.rb

@@ -415,16 +415,56 @@ def compile(input_file_path, *output_file_name)
 
   def replace_singleline_comments(input_file_contents)
 
+    def replace_strings(input_string)
+
+      string_counter = 0
+
+      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
+
+      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
+
     single_line_comments = []
 
     singleline_comment_counter = 1
 
+    modified_file_contents = input_file_contents.clone
+
     for x in 0...input_file_contents.length
 
-      current_row = input_file_contents[x]
+      current_row = replace_strings(input_file_contents[x])
 
       if current_row.include?("#")
 
+        current_row = modified_file_contents[x]
+
         comment_start = current_row.index("#")
 
         if current_row[comment_start+1] != "{"
@@ -439,13 +479,17 @@ def compile(input_file_path, *output_file_name)
 
         end
 
+      else
+
+        current_row = modified_file_contents[x]
+
       end
 
-      input_file_contents[x] = current_row
+      modified_file_contents[x] = current_row
 
     end
 
-    return input_file_contents, single_line_comments
+    return modified_file_contents, single_line_comments
 
   end
 
@@ -477,7 +521,7 @@ def compile(input_file_path, *output_file_name)
 
         key_word_locations << x
 
-      elsif current_row.lstrip.include?("end\n") || current_row.include?("end")
+      elsif current_row.lstrip.eql?("end\n") || current_row.strip.eql?("end")
 
         end_locations << x
 
@@ -525,9 +569,9 @@ def compile(input_file_path, *output_file_name)
 
           modified_file_contents[code_block_begin] = code_block_begin_string
 
-        rescue NoMethodError
-
-          puts "Function compilation failed!"
+        #rescue NoMethodError
+        #
+        #  puts "Function compilation failed!"
 
         end
 
@@ -678,7 +722,7 @@ def compile(input_file_path, *output_file_name)
 
     input_file_contents = input_file_contents.collect {|element| arrayify_right_side(element)}
 
-    possible_variable_lines = input_file_contents.reject { |element| !element.include? "=" }
+    possible_variable_lines = input_file_contents.clone.reject { |element| !element.include? "=" }
 
     possible_parallel_assignment = possible_variable_lines.reject { |element| !element.split("=")[0].include? "," }
 
@@ -766,10 +810,34 @@ def compile(input_file_path, *output_file_name)
 
     end
 
-    possible_default_values = input_file_contents.dup.reject { |element| !element.include?("def") }
+    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|
@@ -802,12 +870,60 @@ def compile(input_file_path, *output_file_name)
 
     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
 
   def get_variables(input_file_contents, temporary_nila_file, *loop_variables)
 
+    def replace_strings(input_string)
+
+      string_counter = 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
+
+      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
+
+      return input_string
+
+    end
+
     variables = []
 
     input_file_contents = input_file_contents.collect { |element| element.gsub("==", "equalequal") }
@@ -826,6 +942,14 @@ def compile(input_file_path, *output_file_name)
 
     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") }
+
+    modified_file_contents = input_file_contents.clone
+
+    input_file_contents = input_file_contents.collect {|element| replace_strings(element)}
+
     javascript_regexp = /(if |while |for )/
 
     for x in 0...input_file_contents.length
@@ -851,6 +975,8 @@ def compile(input_file_path, *output_file_name)
 
         end
 
+        current_row_split[0] = current_row_split[0].split(".",2)[0].strip if current_row_split[0].include?(".")
+
         variables << current_row_split[0]
 
 
@@ -860,7 +986,7 @@ def compile(input_file_path, *output_file_name)
 
     end
 
-    file_contents_as_string = input_file_contents.join
+    file_contents_as_string = modified_file_contents.join
 
     file_id = open(temporary_nila_file, 'w')
 
@@ -890,14 +1016,6 @@ def compile(input_file_path, *output_file_name)
 
     variables = variables.flatten
 
-    if variables.length > 0
-
-      variable_declaration_string = "var " + variables.uniq.sort.join(", ") + "\n\n"
-
-      line_by_line_contents = [variable_declaration_string, line_by_line_contents].flatten
-
-    end
-
     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", "-=") }
@@ -914,6 +1032,10 @@ def compile(input_file_path, *output_file_name)
 
     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 variables.uniq, line_by_line_contents
 
   end
@@ -963,7 +1085,7 @@ def compile(input_file_path, *output_file_name)
 
   end
 
-  def compile_arrays(input_file_contents, temporary_nila_file)
+  def compile_arrays(input_file_contents, named_functions, temporary_nila_file)
 
     def compile_w_arrays(input_file_contents)
 
@@ -1065,7 +1187,7 @@ def compile(input_file_path, *output_file_name)
 
         replacement_string = nil
 
-        if index_end.strip == "end"
+        if index_end.strip == "last"
 
           replacement_string = split1 + ".slice(#{index_start},#{split}.length)\n"
 
@@ -1109,9 +1231,9 @@ def compile(input_file_path, *output_file_name)
 
         replacement_string = nil
 
-        if index_end.strip == "end"
+        if index_end.strip == "last"
 
-          replacement_string = split1 + ".slice(#{index_start})\n"
+          replacement_string = split1 + ".slice(#{index_start})" + split3.strip + "\n\n"
 
         elsif index_end.strip == "" and index_start.strip == ""
 
@@ -1215,7 +1337,7 @@ def compile(input_file_path, *output_file_name)
 
         left, right = usage.split("<<")
 
-        input_file_contents[input_file_contents.index(usage)] = left.rstrip + ".push(#{right.lstrip})"
+        input_file_contents[input_file_contents.index(usage)] = left.rstrip + ".push(#{right.strip})\n\n"
 
       end
 
@@ -1231,7 +1353,15 @@ def compile(input_file_path, *output_file_name)
 
     input_file_contents = compile_array_operators(input_file_contents)
 
-    return input_file_contents
+    named_functions = named_functions.collect {|func| compile_w_arrays(func)}
+
+    named_functions = named_functions.collect { |func| compile_array_indexing(func)}
+
+    named_functions = named_functions.collect {|func| compile_multiline(func, temporary_nila_file)}
+
+    named_functions = named_functions.collect {|func| compile_array_operators(func)}
+
+    return input_file_contents, named_functions
 
 
   end
@@ -1240,8 +1370,40 @@ def compile(input_file_path, *output_file_name)
 
     def compile_multiline_hashes(input_file_contents,temporary_nila_file)
 
+      def replace_strings(input_string)
+
+        string_counter = 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
+
+        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
+
+        return input_string
+
+      end
+
       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?("}") }
@@ -1254,21 +1416,21 @@ def compile(input_file_path, *output_file_name)
 
         index = input_file_contents.index(starting_line)
 
-        line = starting_line
+        line = modified_file_contents[index]
 
         until line.include?("}\n")
 
           index += 1
 
-          line = input_file_contents[index]
+          line = modified_file_contents[index]
 
         end
 
-        multiline_hashes << input_file_contents[input_file_contents.index(starting_line)..index]
+        multiline_hashes << modified_file_contents[input_file_contents.index(starting_line)..index]
 
       end
 
-      joined_file_contents = input_file_contents.join
+      joined_file_contents = modified_file_contents.join
 
       multiline_hashes.each do |hash|
 
@@ -1336,6 +1498,8 @@ def compile(input_file_path, *output_file_name)
 
       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)]
@@ -1586,7 +1750,57 @@ def compile(input_file_path, *output_file_name)
       #This method will pickup and declare all the variables inside a function block. In future, this method will be
       #merged with the get variables method
 
-      controlregexp = /(if |while |def |function |function\()/
+      def replace_strings(input_string)
+
+        element = input_string.gsub("==", "equalequal")
+
+        element = element.gsub("!=", "notequal")
+
+        element = element.gsub("+=", "plusequal")
+
+        element = element.gsub("-=", "minusequal")
+
+        element = element.gsub("*=", "multiequal")
+
+        element = element.gsub("/=", "divequal")
+
+        element = element.gsub("%=", "modequal")
+
+        element = element.gsub("=~", "matchequal")
+
+        element = element.gsub(">=", "greatequal")
+
+        input_string = element.gsub("<=", "lessyequal")
+
+        string_counter = 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
+
+        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
+
+        return input_string
+
+      end
+
+      input_function_block = input_function_block.collect {|element| replace_strings(element)}
+
+      controlregexp = /(if |Euuf |for |while |def |function |function\()/
 
       variables = []
 
@@ -1670,7 +1884,7 @@ def compile(input_file_path, *output_file_name)
 
         if !rejected_array[0].strip.eql?("}")
 
-          if !rejected_array[0].strip.eql?("end")
+          if !rejected_array[0].strip.eql?("end") and !rejected_array[0].strip.include?("--single_line_comment")
 
             last_statement = rejected_array[0]
 
@@ -1996,13 +2210,25 @@ def compile(input_file_path, *output_file_name)
 
     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+" ")
+        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?("")
 
-          modified_file_contents[index] = line.sub(function, function_map_replacements[function])
+          if testsplit[0][-1].eql?(" ") or testsplit[0].eql?("return")
+
+            modified_file_contents[index] = line.sub(function, function_map_replacements[function])
+
+          end
 
         end
 
@@ -2029,7 +2255,14 @@ def compile(input_file_path, *output_file_name)
 
         ".lstrip" => ".replace(/^\\s+/g,\"\")",
 
-        ".rstrip" => ".replace(/\\s+$/g,\"\")"
+        ".rstrip" => ".replace(/\\s+$/g,\"\")",
+
+        ".to_s" => ".toString()",
+
+        ".reverse" => ".reverse()",
+
+        ".empty?" => ".length == 0",
+
     }
 
     method_map = method_map_replacement.keys
@@ -2062,6 +2295,85 @@ def compile(input_file_path, *output_file_name)
 
   end
 
+  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
+
+    def replace_strings(input_string)
+
+      string_counter = 0
+
+      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
+
+      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
+
+    keyword_replacement_map = {
+
+        "nil" => "null",
+
+        "Array.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
+
   def compile_whitespace_delimited_functions(input_file_contents, function_names, temporary_nila_file)
 
     def extract(input_string, pattern_start, pattern_end)
@@ -2306,7 +2618,7 @@ def compile(input_file_path, *output_file_name)
 
         extracted_blocks = []
 
-        controlregexp = /(if |while |def )/
+        controlregexp = /(if |while |def | do )/
 
         rejectionregexp = /( if | while )/
 
@@ -2324,7 +2636,16 @@ def compile(input_file_path, *output_file_name)
 
         possible_if_blocks.each_with_index do |block|
 
-          current_block += block
+          unless current_block[-1] == block[0]
+
+            current_block += block
+
+          else
+
+            current_block += block[1..-1]
+
+          end
+
 
           current_block.each_with_index do |line, index|
 
@@ -2492,7 +2813,7 @@ def compile(input_file_path, *output_file_name)
 
         if_statement_indexes = [0] + if_statement_indexes.flatten + [-1]
 
-        controlregexp = /(while |def )/
+        controlregexp = /(while |def | do )/
 
         modified_input_contents, extracted_statements = extract_if_blocks(if_statement_indexes, input_file_contents.clone)
 
@@ -2604,7 +2925,7 @@ def compile(input_file_path, *output_file_name)
 
         extracted_blocks = []
 
-        controlregexp = /(if |while |def )/
+        controlregexp = /(if |while |def | do )/
 
         rejectionregexp = /( if | while )/
 
@@ -2762,7 +3083,7 @@ def compile(input_file_path, *output_file_name)
 
         while_statement_indexes = [0] + while_statement_indexes.flatten + [-1]
 
-        controlregexp = /(if |def )/
+        controlregexp = /(if |def | do )/
 
         modified_input_contents, extracted_statements = extract_while_blocks(while_statement_indexes, input_file_contents.clone)
 
@@ -2812,7 +3133,7 @@ def compile(input_file_path, *output_file_name)
 
             else
 
-              joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0].join)
+              joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0])
 
               rejected_elements_index.delete_at(0)
 
@@ -2822,7 +3143,7 @@ def compile(input_file_path, *output_file_name)
 
           else
 
-            joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0].join)
+            joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0])
 
             rejected_elements_index.delete_at(0)
 
@@ -2874,7 +3195,7 @@ def compile(input_file_path, *output_file_name)
 
         extracted_blocks = []
 
-        controlregexp = /(if |while |def |for )/
+        controlregexp = /(if |while |def |for | do )/
 
         rejectionregexp = /( if | while )/
 
@@ -3078,7 +3399,7 @@ def compile(input_file_path, *output_file_name)
 
         for_statement_indexes = [0] + for_statement_indexes.flatten + [-1]
 
-        controlregexp = /(if |def |while )/
+        controlregexp = /(if |def |while | do )/
 
         modified_input_contents, extracted_statements = extract_for_blocks(for_statement_indexes, input_file_contents.clone)
 
@@ -3138,7 +3459,7 @@ def compile(input_file_path, *output_file_name)
 
           else
 
-            joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0].join)
+            joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0])
 
             rejected_elements_index.delete_at(0)
 
@@ -3558,6 +3879,10 @@ def compile(input_file_path, *output_file_name)
 
         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") }
+
         javascript_regexp = /(if |while |for )/
 
         for x in 0...input_file_contents.length
@@ -3700,6 +4025,8 @@ def compile(input_file_path, *output_file_name)
 
           times_counter = loop.split(".times")[0].lstrip
 
+          times_counter = times_counter[1...-1] if times_counter.include?("(") and times_counter.include?(")")
+
           replacement_string = "for (_i = 0, _j = #{times_counter}; _i < _j; _i += 1) {\n\n#{compiled_block}\n\n}"
 
           modified_file_contents[input_file_contents.index(original_loop)] = replacement_string
@@ -3728,6 +4055,142 @@ def compile(input_file_path, *output_file_name)
 
   end
 
+  def compile_blocks(input_file_contents,temporary_nila_file)
+
+    def compile_one_line_blocks(input_block)
+
+      block_parameters, block_contents = input_block[1...-1].split("|",2)[1].split("|",2)
+
+      compiled_block = "function(#{block_parameters.lstrip.rstrip}) {\n\n  #{block_contents.strip} \n\n}"
+
+      return compiled_block
+
+    end
+
+    input_file_contents = input_file_contents.collect {|element| element.gsub("append","appand")}
+
+    possible_blocks = input_file_contents.reject {|line| !line.include?(" do ")}
+
+    unless possible_blocks.empty?
+
+      possible_blocks.each do |starting_line|
+
+        index_counter = starting_counter = input_file_contents.index(starting_line)
+
+        line = starting_line
+
+        until line.strip.eql?("end") or line.strip.eql?("end)")
+
+          index_counter += 1
+
+          line = input_file_contents[index_counter]
+
+        end
+
+        loop_extract = input_file_contents[starting_counter..index_counter]
+
+        loop_condition, block = loop_extract.join.split(" do ")
+
+        block = block.split("end")[0]
+
+        replacement_string = "#{loop_condition.rstrip} blockky {#{block.strip}}_!"
+
+        input_file_contents[starting_counter..index_counter] = replacement_string
+
+      end
+
+    end
+
+    possible_blocks = input_file_contents.reject{ |element| !element.include?(" blockky ")}
+
+    possible_blocks = possible_blocks.reject {|element| !element.include?("{") and !element.include?("}")}
+
+    modified_file_contents = input_file_contents.clone
+
+    unless possible_blocks.empty?
+
+      possible_blocks.each do |loop|
+
+        original_loop = loop.clone
+
+        string_counter = 1
+
+        extracted_string = []
+
+        while loop.include?("\"")
+
+          string_extract = loop[loop.index("\"")..loop.index("\"",loop.index("\"")+1)]
+
+          extracted_string << string_extract
+
+          loop = loop.sub(string_extract,"--repstring#{string_counter}")
+
+          string_counter += 1
+
+        end
+
+        block_extract = loop[loop.index("{")..loop.index("}_!")]
+
+        compiled_block = ""
+
+        if block_extract.count("|") == 2
+
+          compiled_block = compile_one_line_blocks(block_extract)
+
+          extracted_string.each_with_index do |string,index|
+
+            compiled_block = compiled_block.sub("--repstring#{index+1}",string)
+
+          end
+
+        else
+
+          compiled_block = block_extract[1...-1].lstrip.rstrip
+
+          extracted_string.each_with_index do |string,index|
+
+            compiled_block = compiled_block.sub("--repstring#{index+1}",string)
+
+          end
+
+        end
+
+        caller_func = loop.split(" blockky ")[0]
+
+        unless caller_func.rstrip[-1] == ","
+
+          replacement_string = "#{caller_func.rstrip}(#{compiled_block.lstrip})"
+
+        else
+
+          caller_func_split = caller_func.split("(") if caller_func.include?("(")
+
+          caller_func_split = caller_func.split(" ",2) if caller_func.include?(" ")
+
+          replacement_string = "#{caller_func_split[0]}(#{caller_func_split[1].strip + compiled_block.lstrip})"
+
+        end
+
+        modified_file_contents[input_file_contents.index(original_loop)] = replacement_string
+
+      end
+
+    end
+
+    modified_file_contents = modified_file_contents.collect {|element| element.gsub("appand","append")}
+
+    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
+
   def add_semicolons(input_file_contents)
 
     def comment(input_string)
@@ -3864,7 +4327,7 @@ def compile(input_file_path, *output_file_name)
 
   end
 
-  def pretty_print_javascript(javascript_file_contents, temporary_nila_file)
+  def pretty_print_javascript(javascript_file_contents, temporary_nila_file,declarable_variables)
 
     def reset_tabs(input_file_contents)
 
@@ -3944,7 +4407,7 @@ def compile(input_file_path, *output_file_name)
 
         end
 
-        block_ending_lines = file_contents.dup.each_index.select { |index| (file_contents[index].eql? "  }\n" or file_contents[index].eql? "  };\n")}
+        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"))}
 
         modified_file_contents = file_contents.dup
 
@@ -3974,19 +4437,19 @@ def compile(input_file_path, *output_file_name)
 
             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") }
+            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]
 
           end
 
-        rescue TypeError
-
-          puts "Whitespace was left unfixed!"
-
-        rescue ArgumentError
-
-          puts "Whitespace was left unfixed!"
+        #rescue TypeError
+        #
+        #  puts "Whitespace was left unfixed!"
+        #
+        #rescue ArgumentError
+        #
+        #  puts "Whitespace was left unfixed!"
 
         end
 
@@ -4018,7 +4481,6 @@ def compile(input_file_path, *output_file_name)
 
         starting_index = code_block_locations[0]
 
-
       end
 
       return compact_contents
@@ -4029,7 +4491,7 @@ def compile(input_file_path, *output_file_name)
 
       if !code_block_starting_locations.empty?
 
-        controlregexp = /(if |for |while |\(function\(|= function\(|((=|:)\s+\{))/
+        controlregexp = /(if |for |while |,function\(|\(function\(|= function\(|((=|:)\s+\{))/
 
         code_block_starting_locations = [0, code_block_starting_locations, -1].flatten
 
@@ -4071,7 +4533,7 @@ def compile(input_file_path, *output_file_name)
 
           current_block.each_with_index do |line, index|
 
-            if line.lstrip.eql? "}\n" or line.lstrip.eql?("};\n") or line.lstrip.include?("_!;\n")
+            if line.lstrip.eql? "}\n" or line.lstrip.eql?("};\n") or line.lstrip.include?("_!;\n") or line.lstrip.include?("});\n")
 
               end_counter += 1
 
@@ -4105,7 +4567,7 @@ def compile(input_file_path, *output_file_name)
 
               block_end = current_block.index(block_extract[-1])
 
-              current_block[block_start..block_end] = "--block#{block_counter}"
+              current_block[block_start..block_end] = "--block#{block_counter}\n"
 
               block_counter += 1
 
@@ -4115,7 +4577,7 @@ def compile(input_file_path, *output_file_name)
 
               current_block.each_with_index do |line, index|
 
-                if line.lstrip.eql? "}\n" or line.lstrip.eql?("};\n") or line.lstrip.include?("_!;\n")
+                if line.lstrip.eql? "}\n" or line.lstrip.eql?("};\n") or line.lstrip.include?("_!;\n") or line.lstrip.include?("});\n")
 
                   end_counter += 1
 
@@ -4159,7 +4621,7 @@ def compile(input_file_path, *output_file_name)
 
     def replace_ignored_words(input_string)
 
-      ignorable_keywords = [/if/, /while/, /function/]
+      ignorable_keywords = [/if/, /while/, /function/,/function/]
 
       dummy_replacement_words = ["eeuuff", "whaalesskkey", "conffoolotion"]
 
@@ -4175,6 +4637,14 @@ def compile(input_file_path, *output_file_name)
 
     javascript_regexp = /(if |for |while |\(function\(|= function\(|((=|:)\s+\{))/
 
+    if declarable_variables.length > 0
+
+      declaration_string = "var " + declarable_variables.flatten.uniq.sort.join(", ") + ";\n\n"
+
+      javascript_file_contents = [declaration_string,javascript_file_contents].flatten
+
+    end
+
     javascript_file_contents = javascript_file_contents.collect { |element| element.sub("Euuf", "if") }
 
     javascript_file_contents = javascript_file_contents.collect { |element| element.sub("whaaleskey", "while") }
@@ -4221,7 +4691,7 @@ def compile(input_file_path, *output_file_name)
 
         current_block = [current_block[0]] + current_block[1...-1].collect { |element| soft_tabs*(soft_tabs_counter)+element } + [current_block[-1]]
 
-        nested_block = current_block.reject { |row| !row.include?("--block") }
+        nested_block = current_block.clone.reject { |row| !row.include?("--block") }
 
         nested_block = nested_block.collect { |element| element.split("--block")[1] }
 
@@ -4229,7 +4699,7 @@ def compile(input_file_path, *output_file_name)
 
         modified_nested_block = nested_block.clone
 
-        current_block = current_block.join
+        current_block = current_block.join("\n")
 
         until modified_nested_block.empty?
 
@@ -4442,6 +4912,8 @@ def compile(input_file_path, *output_file_name)
 
     file_contents = compile_conditional_structures(file_contents, temp_file)
 
+    file_contents = compile_blocks(file_contents,temp_file)
+
     file_contents = compile_integers(file_contents)
 
     file_contents = compile_default_values(file_contents, temp_file)
@@ -4452,18 +4924,22 @@ def compile(input_file_path, *output_file_name)
 
     file_contents = compile_parallel_assignment(file_contents, temp_file)
 
-    file_contents = compile_arrays(file_contents, temp_file)
+    file_contents,named_functions = compile_arrays(file_contents, named_functions, temp_file)
 
     file_contents = compile_strings(file_contents)
 
+    list_of_variables, file_contents = get_variables(file_contents, temp_file,loop_vars)
+
     file_contents, function_names = compile_named_functions(file_contents, named_functions, nested_functions, temp_file)
 
-    list_of_variables, file_contents = get_variables(file_contents, temp_file,loop_vars)
+    func_names = function_names.dup
 
     file_contents, ruby_functions = compile_custom_function_map(file_contents)
 
     file_contents = compile_ruby_methods(file_contents)
 
+    file_contents = compile_special_keywords(file_contents)
+
     function_names << ruby_functions
 
     list_of_variables += loop_vars
@@ -4476,7 +4952,7 @@ def compile(input_file_path, *output_file_name)
 
     file_contents = compile_comments(file_contents, comments, temp_file)
 
-    file_contents = pretty_print_javascript(file_contents, temp_file)
+    file_contents = pretty_print_javascript(file_contents, temp_file,list_of_variables+func_names)
 
     file_contents = compile_operators(file_contents)