nilac 0.0.4.3.9.6 → 0.0.4.3.9.7

data/lib/nilac/compile_monkey_patching.rb

@@ -0,0 +1,189 @@
+# Monkey Patching is an interesting concept. But fair warning, it is not recommended in the Javascript community.
+# We are just implementing it so that we can learn more about Ruby and its Javascript counterpart. This will also serve
+# as a starting point to implement classes.
+
+require_relative 'rollblocks'
+require_relative 'replace_strings'
+require_relative 'read_file_line_by_line'
+
+def compile_monkey_patching(input_file_contents,temporary_nila_file)
+
+  def extract_class_name(input_class_start)
+
+    class_split = input_class_start.strip.split("class ")
+
+    return class_split[1]
+
+  end
+
+  def monkey_patch_errors(input_classes)
+
+    def extract_function_name(input_block_start)
+
+      first_line = input_block_start
+
+      first_line_split = first_line.split("=")
+
+      return first_line_split[0]
+
+    end
+
+    def multiple_same_name_methods(input_class)
+
+      message = ""
+
+      input_class = input_class.collect {|element| element.gsub("(function","&F(^u@#N(C%%")}
+
+      method_blocks = input_class.reject {|element| !replace_strings(element).include?("= function")}
+
+      function_names = []
+
+      proceed_to_next = true
+
+      method_blocks.each do |method_start|
+
+        extract_name = extract_function_name(method_start)
+
+        if function_names.include?(extract_name)
+
+          proceed_to_next = false
+
+          break
+
+        end
+
+        function_names << extract_name
+
+      end
+
+      if proceed_to_next == false
+
+        puts "Hey I discovered two methods by the same name under a potential monkey patched/duck punched Prototype.\n\n"
+
+        puts "Unfortunately that is not allowed because one of your patches is going to be overridden by the other patch.\n\n"
+
+        puts "Please consider changing the code to make sure that all of your patch methods are unique. "
+
+      end
+
+      return proceed_to_next
+
+    end
+
+    proceed_to_next = true
+
+    class_counter = 0
+
+    while proceed_to_next and input_classes.length > class_counter
+
+      proceed_to_next = multiple_same_name_methods(input_classes[class_counter])
+
+      class_counter += 1
+
+    end
+
+    return proceed_to_next
+
+  end
+
+  input_file_contents = input_file_contents.collect {|element| element.gsub("}#@$","}")}
+
+  joined_file_contents = input_file_contents.join
+
+  possible_class_statements = input_file_contents.reject {|element| !replace_strings(element).include?("class ")}
+
+  class_statement_indices = []
+
+  possible_class_statements.each do |statement|
+
+   class_statement_indices << input_file_contents.each_index.select {|index| input_file_contents[index] == statement}
+
+  end
+
+  class_statement_indices = [0,class_statement_indices,-1].flatten.uniq
+
+  file_remains, blocks = extract_blocks(class_statement_indices,input_file_contents,["class","function"])
+
+  class_blocks = blocks.reject {|element| !replace_strings(element[0]).include?("class ")}
+
+  class_blocks = class_blocks.reject {|element| replace_strings(element.join).include?("initialize =")}
+
+  proceed = monkey_patch_errors(class_blocks)
+
+  if proceed
+
+    class_blocks.each do |block|
+
+      class_name = extract_class_name(block[0])
+
+      block = block.collect {|element| element.gsub("(function","&F(^u@#N(C%%")}
+
+      method_starters = block.reject {|element| !replace_strings(element).include?("= function")}
+
+      method_locations = []
+
+      method_starters.each do |element|
+
+        method_locations << block.each_index.select {|index| block[index] == element}
+
+      end
+
+      method_locations = [0,method_locations,-1].flatten.uniq
+
+
+      block_remains, sub_blocks = extract_blocks(method_locations,block[1...-1],["function"])
+
+      sub_method_blocks = sub_blocks.reject {|element| !replace_strings(element[0]).include?("= function")}
+
+      modified_method_blocks = []
+
+      sub_method_blocks.each do |block|
+
+        block[0] = class_name.capitalize + ".prototype." + block[0]
+
+        block = block.collect {|element| element.gsub("&F(^u@#N(C%%","(function")}
+
+        modified_method_blocks << []
+
+        block.each do |statement|
+
+          if replace_strings(statement).include?("self")
+
+            modified_method_blocks[-1] << statement.gsub("self","this")
+
+          else
+
+            modified_method_blocks[-1] << statement
+
+          end
+
+        end
+
+
+      end
+
+      modified_method_blocks.each_with_index do |block,index|
+
+        sub_blocks[sub_blocks.index(sub_method_blocks[index])] = block
+
+      end
+
+      block = block.collect {|element| element.gsub("&F(^u@#N(C%%","(function")}
+
+      joined_file_contents = joined_file_contents.sub(block.join,sub_blocks.join)
+
+    end
+
+    file_id = open(temporary_nila_file, 'w')
+
+    file_id.write(joined_file_contents)
+
+    file_id.close()
+
+    file_contents = read_file_line_by_line(temporary_nila_file)
+
+    return file_contents
+
+  end
+
+end

data/lib/nilac/compile_named_functions.rb

@@ -1,6 +1,8 @@
 require_relative 'strToArray'
-
 require_relative 'read_file_line_by_line'
+require_relative 'paranthesis_compactor'
+require_relative 'replace_strings'
+require_relative 'rollblocks'
 
 def compile_named_functions(input_file_contents, named_code_blocks, nested_functions, temporary_nila_file)
 
@@ -40,54 +42,6 @@ def compile_named_functions(input_file_contents, named_code_blocks, nested_funct
     #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
 
-    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\()/
@@ -106,6 +60,12 @@ def compile_named_functions(input_file_contents, named_code_blocks, nested_funct
 
         current_line_split = line.strip.split("=")
 
+        if current_line_split[0].include?("return")
+
+          current_line_split[0] = current_line_split[0].sub("return","").strip
+
+        end
+
         variables << current_line_split[0].rstrip
 
       end
@@ -324,10 +284,14 @@ def compile_named_functions(input_file_contents, named_code_blocks, nested_funct
 
   def coffee_type_function(input_array)
 
+    input_array = input_array.collect {|element| element.gsub("(function","&F*^u$#N)(&C")}
+
     function_name = input_array[0].split("function ")[1].split("(")[0].lstrip
 
     input_array[0] = "#{function_name} = function(" + input_array[0].split("function ")[1].split("(")[1].lstrip
 
+    input_array = input_array.collect {|element| element.gsub("&F*^u$#N)(&C","(function")}
+
     return input_array
 
   end
@@ -545,7 +509,7 @@ def compile_named_functions(input_file_contents, named_code_blocks, nested_funct
 
   def compile_multiple_ruby_func_calls(input_file_contents)
 
-    def replace_strings(input_string)
+    def replace_complex_strings(input_string)
 
       string_counter = 0
 
@@ -591,39 +555,45 @@ def compile_named_functions(input_file_contents, named_code_blocks, nested_funct
 
     javascript_regexp = /(if |for |while |\(function\(|= function\(|((=|:)\s+\{))/
 
-    stringified_input = input_file_contents.collect {|element| replace_strings(element)}
+    stringified_input = input_file_contents.collect {|element| replace_complex_strings(element)}
 
     function_map.each do |func|
 
       func_calls = input_file_contents.reject {|line| !(line.include?(func+"(") or line.include?(func+" ") and line.index(javascript_regexp) == nil)}
 
-      modified_func_calls = func_calls.collect {|element| replace_strings(element)}
+      unless func_calls.empty?
 
-      modified_func_calls = modified_func_calls.reject {|element| !element.include?(",")}
+        modified_func_calls = func_calls.collect {|element| replace_complex_strings(element)}
 
-      call_collector = []
+        modified_func_calls = modified_func_calls.reject {|element| !element.include?(",")}
 
-      modified_func_calls.each_with_index do |ele|
+        modified_func_calls = modified_func_calls.reject {|element| !compact_paranthesis(element).include?(",")}
 
-        call_collector << input_file_contents[stringified_input.index(ele)]
+        call_collector = []
 
-      end
+        modified_func_calls.each_with_index do |ele|
 
-      function_calls << modified_func_calls
+          call_collector << input_file_contents[stringified_input.index(ele)]
 
-      rep_calls = []
+        end
 
-      call_collector.each do |fcall|
+        function_calls << modified_func_calls
 
-        multiple_call = fcall.split(func)[1].split(",")
+        rep_calls = []
 
-        multiple_call = multiple_call.collect {|element| "\n#{func} " + element.strip + "\n\n"}
+        call_collector.each do |fcall|
 
-        rep_calls << multiple_call.join
+          multiple_call = fcall.split(func)[1].split(",")
 
-      end
+          multiple_call = multiple_call.collect {|element| "\n#{func} " + element.strip + "\n\n"}
+
+          rep_calls << multiple_call.join
+
+        end
+
+        replacement_calls << rep_calls
 
-      replacement_calls << rep_calls
+      end
 
     end
 
@@ -657,15 +627,19 @@ def compile_named_functions(input_file_contents, named_code_blocks, nested_funct
 
       codeblock_counter += 1
 
-      current_nested_functions = nested_functions[codeblock_counter-2]
-
       function_names[codeblock_counter-2] << extract_function_name(codeblock)
 
-      current_nested_functions.each do |nested_function|
+      unless nested_functions.empty?
+
+        current_nested_functions = nested_functions[codeblock_counter-2]
 
-        function_names[codeblock_counter-2] << extract_function_name(nested_function)
+        current_nested_functions.each do |nested_function|
 
-        joined_file_contents = joined_file_contents.sub(nested_function.join, compile_function(nested_function, temporary_nila_file).join)
+          function_names[codeblock_counter-2] << extract_function_name(nested_function)
+
+          joined_file_contents = joined_file_contents.sub(nested_function.join, compile_function(nested_function, temporary_nila_file).join)
+
+        end
 
       end
 

data/lib/nilac/compile_parallel_assignment.rb

@@ -1,6 +1,6 @@
 require_relative 'replace_strings'
-
 require_relative 'read_file_line_by_line'
+require_relative 'paranthesis_compactor'
   
   def compile_parallel_assignment(input_file_contents, temporary_nila_file)
 
@@ -16,7 +16,7 @@ require_relative 'read_file_line_by_line'
 
         right_side = input_string.split("=")[1]
 
-        if right_side.include?(",")
+        if compact_paranthesis(right_side).include?(",")
 
           splits = right_side.split(",")
 

data/lib/nilac/compile_ruby_methods.rb

@@ -65,6 +65,8 @@
 
         ".downcase" => ".toLowerCase()",
 
+        ".zero?" => " === 0",
+
     }
 
     method_map = method_map_replacement.keys
@@ -83,7 +85,7 @@
 
         unless line.include?(method_match + "(")
 
-          line = line.sub(method_match,method_map_replacement[method_match])
+          line = line.gsub(method_match,method_map_replacement[method_match])
 
         end
 

data/lib/nilac/compile_strings.rb

@@ -2,7 +2,7 @@ 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 = input_file_contents.reject { |element| !element.include?(" %q") }
 
     possible_syntax_usage.each do |line|
 
@@ -46,7 +46,7 @@ def compile_strings(input_file_contents)
 
   def compile_big_q_syntax(input_file_contents)
 
-    possible_syntax_usage = input_file_contents.reject { |element| !element.include?("%Q") }
+    possible_syntax_usage = input_file_contents.reject { |element| !element.include?(" %Q") }
 
     possible_syntax_usage.each do |line|
 
@@ -90,9 +90,9 @@ def compile_strings(input_file_contents)
 
   def compile_percentage_syntax(input_file_contents)
 
-    possible_syntax_usage = input_file_contents.reject { |element| !element.include?("%") }
+    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 = possible_syntax_usage.reject { |element| element.index(/(%(\W|\s)\w{1,})/).nil? }
 
     possible_syntax_usage.each do |line|
 

data/lib/nilac/friendly_errors.rb

@@ -0,0 +1,95 @@
+# Nila currently lacks good error messages. So this is an attempt to fix the problem. This module will define a standard
+# set of errors and debugging features that will be utilized by the Nila compiler.
+
+require_relative 'replace_strings'
+require_relative 'rollblocks'
+
+module FriendlyErrors
+
+  def combine_strings(input_list)
+
+    if input_list.length == 1
+
+      return input_list.join
+
+    elsif input_list.length > 1
+
+      last_element = input_list.pop
+
+      statement = input_list.join(", ") + " and #{last_element}"
+
+      return statement
+
+    end
+
+  end
+
+  def file_exist?(file_name)
+
+    message = ""
+
+    proceed_to_next = true
+
+    if File.exist?(file_name)
+
+      unless file_name.include?(".nila")
+
+        message = "Hey! I currently don't have the capacity to compile files other than Nila files. I am sorry!\n\n"
+
+        proceed_to_next = false
+
+      end
+
+    else
+
+      message = "Hey! I cannot find the file specified\n\nCan you check to see if the file exists or accessible?\n\n"
+
+      proceed_to_next = false
+
+    end
+
+    return message, proceed_to_next
+
+  end
+
+  def proper_parsable_statement(file_contents)
+
+    match_expr = [/_(\w{3})_/,/__(\w{3})/,/_(\w{3})_/]
+
+    almost_match = /__(\w{3})__/
+
+    correct_expr = /__END__/
+
+    message = ""
+
+    proceed_to_next = true
+
+    modified_file_contents = file_contents.clone
+
+    possible_parse_end_statements =  file_contents.reject {|element| !replace_strings(element).index(almost_match)}
+
+    parse_end_statements = possible_parse_end_statements.reject {|element| !element.index(correct_expr)}
+
+    if possible_parse_end_statements.length > 1
+
+      line_numbers = []
+
+      possible_parse_end_statements.each do |statement|
+
+        line_numbers << modified_file_contents.index(statement) + 1
+
+        modified_file_contents[line_numbers[-1]-1] = "--enddd_statement"
+
+      end
+
+      message = "Hey! I noticed that you used __END__ statement #{line_numbers.length} times in your file on line numbers #{combine_strings(line_numbers)}.\n\n"
+
+      message += "Unfortunately, this is not allowed. You can only use it once in a file.\n\nPlease remove one of those statements\n\nIf you are confused about the usage of __END__,please refer to the \ndocumentation at http://adhithyan15.github.io/nilac\n\n"
+
+      proceed_to_next = false
+
+    end
+
+  end
+
+end

data/lib/nilac/get_variables.rb

@@ -1,6 +1,6 @@
 require_relative 'replace_strings'
-
 require_relative 'read_file_line_by_line'
+require_relative 'paranthesis_compactor'
   
   def get_variables(input_file_contents, temporary_nila_file, *loop_variables)
 
@@ -40,41 +40,52 @@ require_relative 'read_file_line_by_line'
 
       if current_row.include?("=") and current_row.index(javascript_regexp) == nil and !current_row.include?("#iggggnnnore")
 
-        current_row = current_row.rstrip + "\n"
+        if current_row.index(/,function\(/)
 
-        current_row_split = current_row.split("=")
+          current_row = current_row.strip + "$@#)\n\n"
 
-        for y in 0...current_row_split.length
+        end
 
-          current_row_split[y] = current_row_split[y].strip
+        if compact_paranthesis(current_row).include?("=")
 
+          current_row = current_row.gsub("$@#)\n\n","\n")
 
-        end
+          current_row = current_row.rstrip + "\n"
 
-        if current_row_split[0].include?("[") or current_row_split[0].include?("(")
+          current_row_split = current_row.split("=")
 
-          current_row_split[0] = current_row_split[0][0...current_row_split[0].index("[")]
+          for y in 0...current_row_split.length
 
-        end
+            current_row_split[y] = current_row_split[y].strip
 
-        current_row_split[0] = current_row_split[0].split(".",2)[0].strip if current_row_split[0].include?(".")
 
-        if current_row_split[0].include?(" ")
+          end
 
-          variable_name = current_row_split[0].split
+          if current_row_split[0].include?("[") or current_row_split[0].include?("(")
 
-          variable_name = variable_name.join("_")
+            current_row_split[0] = current_row_split[0][0...current_row_split[0].index("[")]
 
-          modified_file_contents[modified_file_contents.index(original_row)] = modified_file_contents[modified_file_contents.index(original_row)].gsub(current_row_split[0],variable_name)
+          end
 
-        else
+          current_row_split[0] = current_row_split[0].split(".",2)[0].strip if current_row_split[0].include?(".")
 
-          variable_name = current_row_split[0]
+          if current_row_split[0].include?(" ")
 
-        end
+            variable_name = current_row_split[0].split
+
+            variable_name = variable_name.join("_")
 
-        variables << variable_name
+            modified_file_contents[modified_file_contents.index(original_row)] = modified_file_contents[modified_file_contents.index(original_row)].gsub(current_row_split[0],variable_name)
 
+          else
+
+            variable_name = current_row_split[0]
+
+          end
+
+          variables << variable_name
+
+        end
 
       end
 

data/lib/nilac/lexical_scoped_function_variables.rb

@@ -69,6 +69,12 @@ def lexical_scoped_variables(input_function_block)
 
       current_line_split = line.strip.split("=")
 
+      if current_line_split[0].include?("return")
+
+        current_line_split[0] = current_line_split[0].sub("return","").strip
+
+      end
+
       variables << current_line_split[0].rstrip
 
     end

data/lib/nilac/output_javascript.rb

@@ -1,13 +1,15 @@
-  def output_javascript(file_contents, output_file, temporary_nila_file)
+require_relative 'version'
 
-    file_id = open(output_file, 'w')
+def output_javascript(file_contents, output_file, temporary_nila_file)
 
-    File.delete(temporary_nila_file)
+  file_id = open(output_file, 'w')
 
-    file_id.write("//Written using Nila. Visit http://adhithyan15.github.io/nila\n")
+  File.delete(temporary_nila_file)
 
-    file_id.write(file_contents.join)
+  file_id.write("//Written using Nila. Visit http://adhithyan15.github.io/nila\n")
 
-    file_id.close()
+  file_id.write(file_contents.join)
 
-  end
+  file_id.close()
+
+end

data/lib/nilac/paranthesis_compactor.rb

@@ -0,0 +1,37 @@
+def compact_paranthesis(input_string)
+
+  string_extract = input_string.reverse
+
+  paranthesis_extract = [""]
+
+  two_paranthesis = ""
+
+  open_paran_index = nil
+
+  offset_value = nil
+
+  while string_extract.include?("(")
+
+    open_paran_index = string_extract.index("(")
+
+    test_extract = string_extract[0..open_paran_index].reverse
+
+    two_paranthesis = test_extract[0..test_extract.index(")")]
+
+    previous_value = paranthesis_extract[-1]
+
+    if previous_value.length > two_paranthesis.length-(two_paranthesis.count("$@"))/2
+
+      offset_value = previous_value
+
+    end
+
+    paranthesis_extract << two_paranthesis.sub("$@"*previous_value.length,previous_value)
+
+    string_extract = string_extract.sub(two_paranthesis.reverse,"@$"*paranthesis_extract[-1].length)
+
+  end
+
+  return string_extract.reverse
+
+end