nilac 0.0.4.3.9.7.1 → 0.0.4.3.9.8

data/lib/nilac/compile_custom_function_map.rb

@@ -14,7 +14,9 @@ def compile_custom_function_map(input_file_contents)
 
         "alert" => "alert",
 
-        "prompt" => "prompt"
+        "prompt" => "prompt",
+
+        "parseInt" => "parseInt"
 
     }
 
@@ -28,6 +30,8 @@ def compile_custom_function_map(input_file_contents)
 
       function_map.each do |function|
 
+        include_comment = false
+
         test_line = replace_strings(line)
 
         if test_line.include?(function+"(") or test_line.include?(function+" ") and test_line.index(javascript_regexp) == nil
@@ -38,9 +42,27 @@ def compile_custom_function_map(input_file_contents)
 
           testsplit[0] = " " if testsplit[0].eql?("")
 
+          if testsplit[1].include?("--single_line_comment")
+
+            include_comment = true
+
+          end
+
           if testsplit[0][-1].eql?(" ") or testsplit[0].eql?("return")
 
-            modified_file_contents[index] = line.gsub(function, function_map_replacements[function])
+            if include_comment
+
+              modified_line, comment = line.split("--single_line_comment")
+
+              modified_file_contents[index] = modified_line.gsub(function, function_map_replacements[function])
+
+              modified_file_contents[index] = modified_file_contents[index] + "--single_line_comment#{comment}"
+
+            else
+
+              modified_file_contents[index] = line.gsub(function, function_map_replacements[function])
+
+            end
 
           end
 

data/lib/nilac/compile_hashes.rb

@@ -14,6 +14,8 @@ require_relative 'read_file_line_by_line'
 
       possible_hashes = input_file_contents.reject { |element| !element.include?("{") }
 
+      possible_hashes = possible_hashes.reject {|element| element.include?("loop")}
+
       possible_multiline_hashes = possible_hashes.reject { |element| element.include?("}") }
 
       possible_multiline_hashes = possible_multiline_hashes.reject {|element| element.index(javascript_regexp) != nil}
@@ -68,7 +70,7 @@ require_relative 'read_file_line_by_line'
 
     def compile_inline_hashes(input_file_contents)
 
-      javascript_regexp = /(if |while |for |function |function\(|%[qQw]*\{|lambda\s*\{|\s*->\s*\{)/
+      javascript_regexp = /(if |while |for |function |function\(|%[qQw]*\{|lambda\s*\{|\s*->\s*\{|loop\s*)/
 
       modified_file_contents = input_file_contents.clone.collect {|element| replace_strings(element)}
 

data/lib/nilac/compile_heredocs.rb

@@ -44,6 +44,8 @@ require_relative 'read_file_line_by_line'
 
       end
 
+      replacement_string = replacement_string.gsub("\\#","#")
+
       joined_file_contents = joined_file_contents.sub(heredoc + heredoc_extract + delimiter, replacement_string)
 
     end

data/lib/nilac/compile_inline_for.rb

@@ -0,0 +1,13 @@
+require_relative 'replace_strings'
+
+def compile_inline_for(input_file_contents)
+
+  test_regex = /( for )/
+
+  possible_inline_for = input_file_contents.reject {|element| element.index(test_regex).nil?}
+
+  possible_inline_for = possible_inline_for.reject {|element| element.rstrip.lstrip.index(test_regex).nil?}
+
+
+
+end

data/lib/nilac/compile_interpolated_strings.rb

@@ -1,7 +1,74 @@
 require_relative 'find_all_matching_indices'
+require_relative 'replace_strings'
+require_relative 'extract_strings'
+require_relative 'replace_comparison_operators'
   
   def compile_interpolated_strings(input_file_contents)
 
+    def interpolation_variables(input_string)
+
+      interpolation_vars = []
+
+      modified_expressions = []
+
+      input_string = input_string[2..-1]
+
+      if replace_strings(input_string).include?(",")
+
+        replaced_string = replace_strings(input_string)
+
+        extracted_strings = extract_strings(input_string)
+
+        semicolon_seperated_expressions = replaced_string.split(",")
+
+        semicolon_seperated_expressions.each do |expr|
+
+          matched_strings = expr.scan(/--repstring\d+/).to_a
+
+          if matched_strings.empty?
+
+            modified_expressions << expr
+
+          else
+
+            matched_strings.each do |str|
+
+              junk,string_id = str.split("--repstring")
+
+              modified_expressions << expr.sub("--repstring#{string_id}",extracted_strings[string_id.to_i])
+
+            end
+
+          end
+
+        end
+
+      end
+
+      if modified_expressions.empty?
+
+        modified_expressions << input_string
+
+      end
+
+      modified_expressions.each do |expr|
+
+        if replace_strings(expr).include?("=")
+
+          replaced_string = replace_strings(expr)
+
+          string_split = replaced_string.split("=")
+
+          interpolation_vars << string_split[0].strip
+
+        end
+
+      end
+
+      return interpolation_vars
+
+    end
+
     def replace_string_arrays(input_string)
 
       def extract(input_string, pattern_start, pattern_end)
@@ -32,10 +99,16 @@ require_relative 'find_all_matching_indices'
 
     end
 
+    interpolation_vars = []
+
     modified_file_contents = input_file_contents.dup
 
     single_quoted_strings = input_file_contents.reject { |element| !(element.count("'") >= 2) }
 
+    single_quoted_string_array = []
+
+    single_quote_counter = 0
+
     single_quoted_strings.each do |str|
 
       modified_string = str.dup
@@ -46,7 +119,11 @@ require_relative 'find_all_matching_indices'
 
         string_extract = modified_string[first_index..modified_string.index("'", first_index+1)]
 
-        modified_string = modified_string.sub(string_extract, "--single_quoted")
+        single_quoted_string_array << string_extract
+
+        modified_string = modified_string.sub(string_extract, "--single_quoted#{single_quote_counter}")
+
+        single_quote_counter += 1
 
       end
 
@@ -60,6 +137,20 @@ require_relative 'find_all_matching_indices'
 
         modified_line = line.dup
 
+        possible_single_quoted_strings = modified_line.scan(/--single_quoted\d+/).to_a
+
+        unless possible_single_quoted_strings.empty?
+
+          possible_single_quoted_strings.each do |quoted_string|
+
+            junk,string_id = quoted_string.split("--single_quoted")
+
+            modified_line = modified_line.sub("--single_quoted#{string_id}",single_quoted_string_array[string_id.to_i])
+
+          end
+
+        end
+
         interpol_starting_loc = find_all_matching_indices(modified_line, "\#{") + [-1]
 
         interpolated_strings = []
@@ -130,25 +221,111 @@ require_relative 'find_all_matching_indices'
 
         interpolated_strings.each do |interpol|
 
+          original_interpol = interpol.clone
+
           string_split = line.split(interpol)
 
           if string_split[1].eql?("\"\n")
 
+            if replace_strings(interpol).include?(";")
+
+              interpol = replace_strings(interpol)
+
+              string_extracts = extract_strings(interpol)
+
+              interpol = interpol.gsub(";",",")
+
+              string_extracts.each do |str|
+
+                matched_strings = str.scan(/--repstring/).to_a
+
+                matched_strings.each do |matched_string|
+
+                  junk,string_id = matched_string.split("--repstring")
+
+                  interpol = interpol.sub("--repstring#{string_id}",string_extracts[string_id.to_i])
+
+                end
+
+              end
+
+              interpol = replace_comparison_operators(interpol)
+
+            end
+
+            interpolation_variables(interpol)
+
             replacement_string = "\" + " + "(#{interpol[2...-1]})"
 
-            modified_file_contents[index] = modified_file_contents[index].sub(interpol+"\"", replacement_string)
+            modified_file_contents[index] = modified_file_contents[index].sub(original_interpol+"\"", replacement_string)
 
           elsif string_split[1].eql?("\")\n")
 
+            if replace_strings(interpol).include?(";")
+
+              interpol = replace_strings(interpol)
+
+              string_extracts = extract_strings(interpol)
+
+              interpol = interpol.gsub(";",",")
+
+              string_extracts.each do |str|
+
+                matched_strings = str.scan(/--repstring/).to_a
+
+                matched_strings.each do |matched_string|
+
+                  junk,string_id = matched_string.split("--repstring")
+
+                  interpol = interpol.sub("--repstring#{string_id}",string_extracts[string_id.to_i])
+
+                end
+
+              end
+
+              interpol = replace_comparison_operators(interpol)
+
+            end
+
+            interpolation_variables(interpol)
+
             replacement_string = "\" + " + "(#{interpol[2...-1]})"
 
-            modified_file_contents[index] = modified_file_contents[index].sub(interpol + "\"", replacement_string)
+            modified_file_contents[index] = modified_file_contents[index].sub(original_interpol + "\"", replacement_string)
 
           else
 
+            if replace_strings(interpol).include?(";")
+
+              interpol = replace_strings(interpol)
+
+              string_extracts = extract_strings(interpol)
+
+              interpol = interpol.gsub(";",",")
+
+              string_extracts.each do |str|
+
+                matched_strings = str.scan(/--repstring/).to_a
+
+                matched_strings.each do |matched_string|
+
+                  junk,string_id = matched_string.split("--repstring")
+
+                  interpol = interpol.sub("--repstring#{string_id}",string_extracts[string_id.to_i])
+
+                end
+
+              end
+
+              interpol = replace_comparison_operators(interpol)
+
+            end
+
+             interpolation_vars << interpolation_variables(interpol)
+
             replacement_string = "\"" + " + " + "(#{interpol[2...-1]})" + " + \""
 
-            modified_file_contents[index] = modified_file_contents[index].sub(interpol, replacement_string)
+            modified_file_contents[index] = modified_file_contents[index].sub(original_interpol, replacement_string)
 
           end
 
@@ -158,6 +335,8 @@ require_relative 'find_all_matching_indices'
 
     end
 
-    return modified_file_contents
+    interpolation_vars = interpolation_vars.flatten.uniq
+
+    return modified_file_contents, interpolation_vars
 
   end

data/lib/nilac/compile_lambdas.rb

@@ -12,7 +12,15 @@ def compile_lambdas(input_file_contents,temporary_nila_file)
 
     if parameterless
 
-      block_contents = input_block[3...-1]
+      if input_block[0] = "{" and input_block[-1] = "}"
+
+        block_contents = input_block[1...-1]
+
+      else
+
+        block_contents = input_block[3...-1]
+
+      end
 
       compiled_lambda = "function() {\n\n  #{block_contents.strip} \n\n}"
 
@@ -48,7 +56,9 @@ def compile_lambdas(input_file_contents,temporary_nila_file)
 
   input_file_contents = input_file_contents.collect {|element| (replace_strings(element).include?(" -> ") ? element.gsub(" -> "," lambda ") : element)}
 
-  input_file_contents = input_file_contents.collect {|element| element.gsub("append","appand")}
+  input_file_contents = input_file_contents.collect {|element| element.gsub("document","decccccumennt")}
+
+  input_file_contents = input_file_contents.collect {|element| element.gsub("append","appand").gsub(" do"," do ").gsub("do "," do ")}
 
   possible_lambdas = input_file_contents.reject {|line| !replace_strings(line).include?("lambda")}
 
@@ -74,7 +84,7 @@ def compile_lambdas(input_file_contents,temporary_nila_file)
 
       loop_extract = input_file_contents[starting_counter..index_counter]
 
-      var_name,block = loop_extract.join.split(/\s*do/)
+      var_name,block = loop_extract.join.split(/\s*do\s+/)
 
       var_name = var_name.split(/\s*=\s*lambda/)[0].strip
 
@@ -92,15 +102,17 @@ def compile_lambdas(input_file_contents,temporary_nila_file)
 
   possible_lambdas = possible_lambdas.reject {|element| !element.include?("{") and !element.include?("}")}
 
-  possible_lambdas = possible_lambdas.collect {|element| element.gsub(/lambda\s*\{/,"lambda !_{")}
-
   modified_file_contents = input_file_contents.clone
 
   unless possible_lambdas.empty?
 
-    possible_lambdas.each do |loop|
+    original_loops = possible_lambdas.clone
+
+    possible_lambdas = possible_lambdas.collect {|element| element.gsub(/lambda\s*\{/,"lambda !_{")}
 
-      original_loop = loop.clone
+    possible_lambdas.each_with_index do |loop,index|
+
+      original_loop = original_loops[index]
 
       string_counter = 1
 
@@ -182,7 +194,9 @@ def compile_lambdas(input_file_contents,temporary_nila_file)
 
       replacement_string = replacement_array.join
 
-      modified_file_contents[input_file_contents.index(original_loop)] = replacement_string[-1].eql?(";") ? replacement_string : replacement_string + ";"
+      replacement_string = replacement_string[-1].eql?(";") ? replacement_string : (replacement_string + ";")
+
+      modified_file_contents[input_file_contents.index(original_loop)] = (replacement_string + "\n\n")
 
     end
 
@@ -190,6 +204,8 @@ def compile_lambdas(input_file_contents,temporary_nila_file)
 
   modified_file_contents = modified_file_contents.collect {|element| element.gsub("appand","append")}
 
+  modified_file_contents = modified_file_contents.collect {|element| element.gsub("decccccumennt","document")}
+
   file_id = open(temporary_nila_file, 'w')
 
   file_id.write(modified_file_contents.join)

data/lib/nilac/compile_new_keyword.rb

@@ -0,0 +1,37 @@
+require_relative 'replace_strings'
+
+def compile_new_keyword(input_file_contents)
+
+  # This construct compiles builtin Ruby type initializations to Javascript equivalents
+
+  # Eg: String.new(somestring) => new String(somestring)
+
+  match_hash = {
+
+      "String.new" => "new String",
+
+  }
+
+  replaced_contents = input_file_contents.collect {|element| replace_strings(element)}
+
+  matchables = match_hash.keys
+
+  matched_values = match_hash.values
+
+  matchables.each_with_index do |key,key_index|
+
+    replaced_contents.each_with_index do |element,index|
+
+      if element.include?(key)
+
+        input_file_contents[index] = input_file_contents[index].gsub(key,matched_values[key_index])
+
+      end
+
+    end
+
+  end
+
+  return input_file_contents
+
+end