nilac 0.0.4.3.9.5 → 0.0.4.3.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 193275e07ff9a381b98f8cba61b4178b4aa67746
-  data.tar.gz: fdb154e462dccec62c8b6c92221303d86c47c50f
+  metadata.gz: 2aae60bb21de5dafc4e90454f1b4f6fb98b222ef
+  data.tar.gz: 5be7a1d1fa7e3ead44e3163463b3ac191ea60442
 SHA512:
-  metadata.gz: e46d6cf55cd21f52feed937192522cc287a34e79979b2f8cbb199154d8cddb38b279b1ccab3bb6a69533df0bb93e557d21c408051ed903f47e7a1b78e8e81513
-  data.tar.gz: 46eabf7a2ad1f5188e1398120971fcc0ecbcacf7befb88b0f067da15dbc02f79d4d0a99e88c57178612783c81c3e1ea93073c7e02f6a887d4710c5ecf551b971
+  metadata.gz: e049e7f5ade3d9c6f6652bce8a5cdb4489719954f3ba1dad8a5e356b48400a1d2be5a2389c6a93a92c2e7d0b541492cfea24c9cff66aa91061e511e81c0012d4
+  data.tar.gz: e47c6c6f6f95a0e06115257adf24d8a3e2fac841883a5365920a4c0aa86c3bb10d01b67df0ca1178198578a7f9d967c1279a047e14c010545e956f8cf8b35337

data/examples/marky.nila

@@ -13,7 +13,7 @@ require 'fs'
 def parse_markdown(input_file)
 
   fs.readFile input_file, 'utf8', do |err,data| 
-      puts err if err
+      
       puts data
   end
 

data/lib/nilac/add_auto_return_statement.rb

@@ -0,0 +1,33 @@
+def add_auto_return_statement(input_array)
+
+  joined_array = input_array.join
+
+  reversed_input_array = input_array.reverse
+
+  if !joined_array.include?("return ")
+
+    rejected_array = reversed_input_array.reject { |content| content.lstrip.eql?("") }
+
+    rejected_array = rejected_array.reject {|content| content.strip.eql?("")}
+
+    rejected_array = rejected_array[1..-1]
+
+    unless rejected_array[0].strip.eql?("}") or rejected_array[0].strip.eql?("})")
+
+      if !rejected_array[0].strip.eql?("end") and !rejected_array[0].strip.include?("--single_line_comment")
+
+        last_statement = rejected_array[0]
+
+        replacement_string = "return #{last_statement.lstrip}"
+
+        input_array[input_array.index(last_statement)] = replacement_string
+
+      end
+
+    end
+
+  end
+
+  return input_array
+
+end

data/lib/nilac/add_semicolons.rb

@@ -18,6 +18,8 @@
 
     end
 
+    input_file_contents = input_file_contents.collect {|element| element.gsub("#iggggnnnore ","")}
+
     reject_regexp = /(function |Euuf |if |else|elsuf|switch |case|while |whaaleskey |for )/
 
     modified_file_contents = input_file_contents.dup

data/lib/nilac/compile_blocks.rb

@@ -1,4 +1,6 @@
 require_relative 'read_file_line_by_line'
+require_relative 'strToArray'
+require_relative 'lexical_scoped_function_variables'
   
   def compile_blocks(input_file_contents,temporary_nila_file)
 
@@ -6,6 +8,12 @@ require_relative 'read_file_line_by_line'
 
       block_parameters, block_contents = input_block[1...-1].split("|",2)[1].split("|",2)
 
+      if block_parameters.include?("err") and !block_contents.include?("err")
+
+        block_contents = "if (err) {\n puts err \n}\n" + block_contents
+
+      end
+
       compiled_block = "function(#{block_parameters.lstrip.rstrip}) {\n\n  #{block_contents.strip} \n\n}"
 
       return compiled_block
@@ -102,7 +110,7 @@ require_relative 'read_file_line_by_line'
 
         caller_func = loop.split(" blockky ")[0]
 
-        unless caller_func.rstrip[-1] == ","
+        unless caller_func.strip[-1] == ","
 
           replacement_string = "#{caller_func.rstrip}(#{compiled_block.lstrip})"
 
@@ -116,7 +124,21 @@ require_relative 'read_file_line_by_line'
 
         end
 
-        modified_file_contents[input_file_contents.index(original_loop)] = replacement_string
+        replacement_array = strToArray(replacement_string)
+
+        variables = lexical_scoped_variables(replacement_array)
+
+        if !variables.empty?
+
+          variable_string = "\nvar " + variables.join(", ") + "\n"
+
+          replacement_array.insert(1, variable_string)
+
+        end
+
+        replacement_array[1...-1] = replacement_array[1...-1].collect {|element| "#iggggnnnore #{element}"}
+
+        modified_file_contents[input_file_contents.index(original_loop)] = replacement_array.join
 
       end
 

data/lib/nilac/compile_custom_function_map.rb

@@ -12,6 +12,8 @@ def compile_custom_function_map(input_file_contents)
 
         "require" => "require",
 
+        "alert" => "alert"
+
     }
 
     function_map = function_map_replacements.keys
@@ -28,7 +30,7 @@ def compile_custom_function_map(input_file_contents)
 
         if test_line.include?(function+"(") or test_line.include?(function+" ") and test_line.index(javascript_regexp) == nil
 
-          testsplit =  line.split(function)
+          testsplit =  line.gsub("#iggggnnnore","").split(function)
 
           testsplit = testsplit.collect {|element| element.strip}
 
@@ -36,7 +38,7 @@ def compile_custom_function_map(input_file_contents)
 
           if testsplit[0][-1].eql?(" ") or testsplit[0].eql?("return")
 
-            modified_file_contents[index] = line.sub(function, function_map_replacements[function])
+            modified_file_contents[index] = line.gsub(function, function_map_replacements[function])
 
           end
 

data/lib/nilac/compile_existential_operator.rb

@@ -2,6 +2,92 @@ require_relative 'replace_strings'
 
 def compile_existential_operators(input_file_contents)
 
+  # This method compiles Nila's existential operator.
+  #
+  # Example:
+  #
+  # input_args[0].exist?
+  #
+  # The above line should compile to
+  #
+  # typeof input_args[0] !== undefined && input_args[0] !== nil
+
+  modified_contents = input_file_contents.collect {|element| replace_strings(element)}
+
+  possible_existential_calls = modified_contents.reject {|element| !element.include?(".exist")}
+
+  split_regexp = /((if|while) \((!\()?)/
+
+  second_split_regexp = /(&&|\|\|)/
+
+  possible_existential_calls.each do |statement|
+
+    reconstructed_statement = input_file_contents[modified_contents.index(statement)]
+
+    counter = 0
+
+    while reconstructed_statement.include?(".exist")
+
+      before,after = reconstructed_statement.split(".exist",2)
+
+      if counter == 0
+
+        split_data = before.split(split_regexp)
+
+        before2 = split_data[1]
+
+        if before2.eql?("if (") or before2.eql?("while (")
+
+          usage = split_data[3]
+
+        elsif before2.eql?("if (!(") or before2.eql?("while (!(")
+
+          usage = split_data[4]
+
+        end
+
+        replacement_string = "(typeof #{usage} !== \"undefined\" &|&| #{usage} !== null)"
+
+        reconstructed_statement = before.split(before2)[0] + before2 + replacement_string + after
+
+      elsif counter > 0
+
+        split_data = before.split(second_split_regexp)
+
+        before2 = split_data[0]
+
+        operator = split_data[1]
+
+        operator = " &|&| " if operator.strip.eql?("&&")
+
+        operator = " |$|$ " if operator.strip.eql?("||")
+
+        usage = split_data[2]
+
+        replacement_string = "(typeof #{usage} !== \"undefined\" &|&| #{usage} !== null)"
+
+        reconstructed_statement = before2 + operator + replacement_string + after
+
+      end
+
+      counter += 1
+
+    end
+
+    reconstructed_statement = reconstructed_statement.gsub("&|&|","&&").gsub("|$|$","&&")
+
+    input_file_contents[modified_contents.index(statement)] = reconstructed_statement
+
+    modified_contents = input_file_contents
+
+  end
+
+  return input_file_contents
+
+end
+
+def compile_nil_operator(input_file_contents)
+
   # This method compiles Nila's existential operator.
   #
   # Example:
@@ -10,7 +96,7 @@ def compile_existential_operators(input_file_contents)
   #
   # The above line should compile to
   #
-  # typeof input_args[0] === undefined && input_args[0] === nil
+  # input_args[0] === nil
 
   modified_contents = input_file_contents.collect {|element| replace_strings(element)}
 
@@ -46,7 +132,7 @@ def compile_existential_operators(input_file_contents)
 
         end
 
-        replacement_string = "(typeof #{usage} === \"undefined\" &|&| #{usage} === null)"
+        replacement_string = "(#{usage} === null)"
 
         reconstructed_statement = before.split(before2)[0] + before2 + replacement_string + after
 
@@ -64,7 +150,7 @@ def compile_existential_operators(input_file_contents)
 
         usage = split_data[2]
 
-        replacement_string = "(typeof #{usage} === \"undefined\" &|&| #{usage} === null)"
+        replacement_string = "(#{usage} === null)"
 
         reconstructed_statement = before2 + operator + replacement_string + after
 
@@ -78,6 +164,8 @@ def compile_existential_operators(input_file_contents)
 
     input_file_contents[modified_contents.index(statement)] = reconstructed_statement
 
+    modified_contents = input_file_contents
+
   end
 
   return input_file_contents
@@ -162,6 +250,8 @@ def compile_undefined_operator(input_file_contents)
 
     input_file_contents[modified_contents.index(statement)] = reconstructed_statement
 
+    modified_contents = input_file_contents
+
   end
 
   return input_file_contents

data/lib/nilac/compile_hashes.rb

@@ -68,7 +68,7 @@ require_relative 'read_file_line_by_line'
 
     def compile_inline_hashes(input_file_contents)
 
-      javascript_regexp = /(if |while |for |function |function\(|%[qQw]*\{)/
+      javascript_regexp = /(if |while |for |function |function\(|%[qQw]*\{|lambda\s*\{|\s*->\s*\{)/
 
       modified_file_contents = input_file_contents.clone.collect {|element| replace_strings(element)}
 

data/lib/nilac/compile_lambdas.rb

@@ -0,0 +1,187 @@
+require_relative 'replace_strings'
+require_relative 'compile_multiple_return'
+require_relative 'strToArray'
+require_relative 'lexical_scoped_function_variables'
+require_relative 'add_auto_return_statement'
+
+def compile_lambdas(input_file_contents,temporary_nila_file)
+
+  def compile_single_line_lambda(input_block)
+
+    # This method compiles a single lambda into a Javascript function expression
+
+    block_parameters, block_contents = input_block[1...-1].split("|",2)[1].split("|",2)
+
+    compiled_lambda = "function(#{block_parameters.lstrip.rstrip}) {\n\n  #{block_contents.strip} \n\n}"
+
+    return compiled_lambda
+
+  end
+
+  def find_lambda_name(input_block)
+
+    first_line = input_block[0]
+
+    var_name = "varrrr"
+
+    if first_line.include?("=")
+
+      var_name,junk = first_line.split("=")
+
+      var_name = var_name.strip
+
+    end
+
+    return var_name
+
+  end
+
+  input_file_contents = input_file_contents.collect {|element| element.gsub(" -> "," lambda ")}
+
+  input_file_contents = input_file_contents.collect {|element| element.gsub("append","appand")}
+
+  possible_lambdas = input_file_contents.reject {|line| !replace_strings(line).include?("lambda")}
+
+  possible_lambdas = possible_lambdas.reject {|line| line.index(/\s*do\s*/) == nil}
+
+  lambda_names = []
+
+  unless possible_lambdas.empty?
+
+    possible_lambdas.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]
+
+      var_name,block = loop_extract.join.split(/\s*do/)
+
+      var_name = var_name.split(/\s*=\s*lambda/)[0].strip
+
+      block = block.split("end")[0]
+
+      replacement_string = "#{var_name} = lambda blockky {#{block.strip}}_!"
+
+      input_file_contents[starting_counter..index_counter] = replacement_string
+
+    end
+
+  end
+
+  possible_lambdas = input_file_contents.reject{ |element| element.index(/lambda\s*(blockky)?\s*/) == nil}
+
+  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_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
+
+      lambda_extract = loop[loop.index("{")..loop.index("}_!")] if loop.include?("}_!")
+
+      lambda_extract = loop[loop.index("!_{")..loop.index("}")] if loop.include?("!_{")
+
+      compiled_lambda = ""
+
+      if lambda_extract.count("|") == 2
+
+        compiled_lambda = compile_single_line_lambda(lambda_extract)
+
+        extracted_string.each_with_index do |string,index|
+
+          compiled_lambda = compiled_lambda.sub("--repstring#{index+1}",string)
+
+        end
+
+      else
+
+        compiled_lambda = lambda_extract[1...-1].lstrip.rstrip
+
+        extracted_string.each_with_index do |string,index|
+
+          compiled_lambda = compiled_lambda.sub("--repstring#{index+1}",string)
+
+        end
+
+      end
+
+      original_loop = original_loop.gsub("!_{","{")
+
+      replacement_string = loop.split(lambda_extract)[0].split("lambda")[0] + compiled_lambda
+
+      replacement_array = strToArray(replacement_string)
+
+      replacement_array = compile_multiple_return(replacement_array)
+
+      replacement_array = add_auto_return_statement(replacement_array)
+
+      variables = lexical_scoped_variables(replacement_array)
+
+      if !variables.empty?
+
+        variable_string = "\nvar " + variables.join(", ") + "\n"
+
+        replacement_array.insert(1, variable_string)
+
+      end
+
+      lambda_name = find_lambda_name(replacement_array)
+
+      unless lambda_name.eql?("varrrr")
+
+        lambda_names << lambda_name
+
+      end
+
+      replacement_array[1...-1] = replacement_array[1...-1].collect {|element| "#iggggnnnore #{element}"}
+
+      modified_file_contents[input_file_contents.index(original_loop)] = replacement_array.join
+
+    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,lambda_names
+
+end

data/lib/nilac/compile_multiple_return.rb

@@ -0,0 +1,127 @@
+def compile_multiple_return(input_array)
+
+  def find_all_matching_indices(input_string, pattern)
+
+    locations = []
+
+    index = input_string.index(pattern)
+
+    while index != nil
+
+      locations << index
+
+      index = input_string.index(pattern, index+1)
+
+
+    end
+
+    return locations
+
+
+  end
+
+  modified_input_array = input_array.dup
+
+  return_statements = input_array.dup.reject { |element| !element.include? "return" }
+
+  multiple_return_statements = return_statements.dup.reject { |element| !element.include? "," }
+
+  modified_multiple_return_statements = multiple_return_statements.dup
+
+  return_statement_index = []
+
+  multiple_return_statements.each do |statement|
+
+    location_array = modified_input_array.each_index.select { |index| modified_input_array[index] == statement }
+
+    return_statement_index << location_array[0]
+
+  end
+
+  multiple_return_statements.each_with_index do |return_statement, index|
+
+    replacement_counter = 0
+
+    if return_statement.include? "\""
+
+      starting_quotes = find_all_matching_indices(return_statement, "\"")
+
+      for x in 0...(starting_quotes.length)/2
+
+        quotes = return_statement[starting_quotes[x]..starting_quotes[x+1]]
+
+        replacement_counter += 1
+
+        modified_multiple_return_statements[index] = modified_multiple_return_statements[index].sub(quotes, "repstring#{1}")
+
+        modified_input_array[return_statement_index[index]] = modified_multiple_return_statements[index].sub(quotes, "repstring#{1}")
+
+      end
+
+    end
+
+  end
+
+  modified_multiple_return_statements = modified_multiple_return_statements.reject { |element| !element.include? "," }
+
+  return_statement_index = []
+
+  modified_multiple_return_statements.each do |statement|
+
+    location_array = modified_input_array.each_index.select { |index| modified_input_array[index] == statement }
+
+    return_statement_index << location_array[0]
+
+  end
+
+  modified_multiple_return_statements.each_with_index do |return_statement, index|
+
+    method_call_counter = 0
+
+    if return_statement.include? "("
+
+      open_paran_location = find_all_matching_indices(return_statement, "(")
+
+      open_paran_location.each do |paran_index|
+
+        method_call = return_statement[paran_index..return_statement.index(")", paran_index+1)]
+
+        method_call_counter += 1
+
+        modified_multiple_return_statements[index] = modified_multiple_return_statements[index].sub(method_call, "methodcall#{method_call_counter}")
+
+        modified_input_array[return_statement_index[index]] = modified_multiple_return_statements[index].sub(method_call, "methodcall#{method_call_counter}")
+
+      end
+
+    end
+
+  end
+
+  modified_multiple_return_statements = modified_multiple_return_statements.reject { |element| !element.include?(",") }
+
+  return_statement_index = []
+
+  modified_multiple_return_statements.each do |statement|
+
+    location_array = modified_input_array.each_index.select { |index| modified_input_array[index] == statement }
+
+    return_statement_index << location_array[0]
+
+  end
+
+  return_statement_index.each do |index|
+
+    original_statement = input_array[index]
+
+    statement_split = original_statement.split("return ")
+
+    replacement_split = "return [" + statement_split[1].rstrip + "]\n\n"
+
+    input_array[index] = replacement_split
+
+  end
+
+  return input_array
+
+end

data/lib/nilac/compile_operators.rb

@@ -66,6 +66,33 @@ def compile_operators(input_file_contents)
 
   end
 
+  def compile_conditional_assignment(input_string)
+
+    if input_string.include?("||=")
+
+      before,after = input_string.split("||=")
+
+      replacement_string = before + " = #{before.lstrip} || #{after}"
+
+      input_string = replacement_string
+
+    end
+
+    if input_string.include?("&&=")
+
+      before, after = input_string.split("&&=")
+
+      replacement_string = before + " = #{before.lstrip} && #{after}"
+
+      input_string = replacement_string
+
+    end
+
+    return input_string
+
+
+  end
+
   input_file_contents = input_file_contents.collect { |element| element.sub("==", "===") }
 
   input_file_contents = input_file_contents.collect { |element| element.sub("!=", "!==") }
@@ -74,10 +101,14 @@ def compile_operators(input_file_contents)
 
   input_file_contents = input_file_contents.collect { |element| element.sub("elsuf", "else if") }
 
+  input_file_contents = input_file_contents.collect {|element| compile_conditional_assignment(element)}
+
   input_file_contents = compile_existential_operators(input_file_contents)
 
   input_file_contents = compile_undefined_operator(input_file_contents)
 
+  input_file_contents = compile_nil_operator(input_file_contents)
+
   input_file_contents = input_file_contents.collect { |element| compile_power_operator(element) }
 
   input_file_contents = input_file_contents.collect { |element| compile_match_operator(element) }

data/lib/nilac/extract_parsable_file.rb

@@ -1,5 +1,7 @@
 def extract_parsable_file(input_file_contents)
 
+  input_file_contents = input_file_contents.collect {|element| element.gsub(".?",".exist?")}
+
   reversed_file_contents = input_file_contents.reverse
 
   line_counter = 0

data/lib/nilac/get_variables.rb

@@ -30,13 +30,15 @@ require_relative 'read_file_line_by_line'
 
     input_file_contents = input_file_contents.collect {|element| replace_strings(element)}
 
-    javascript_regexp = /(if |while |for )/
+    javascript_regexp = /(if |while |for |\|\|=|&&=)/
 
     for x in 0...input_file_contents.length
 
       current_row = input_file_contents[x]
 
-      if current_row.include?("=") and current_row.index(javascript_regexp) == nil
+      original_row = current_row.clone
+
+      if current_row.include?("=") and current_row.index(javascript_regexp) == nil and !current_row.include?("#iggggnnnore")
 
         current_row = current_row.rstrip + "\n"
 
@@ -57,12 +59,24 @@ require_relative 'read_file_line_by_line'
 
         current_row_split[0] = current_row_split[0].split(".",2)[0].strip if current_row_split[0].include?(".")
 
-        variables << current_row_split[0]
+        if current_row_split[0].include?(" ")
 
+          variable_name = current_row_split[0].split
 
-      end
+          variable_name = variable_name.join("_")
+
+          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)
 
-      input_file_contents[x] = current_row
+        else
+
+          variable_name = current_row_split[0]
+
+        end
+
+        variables << variable_name
+
+
+      end
 
     end
 
@@ -84,8 +98,6 @@ require_relative 'read_file_line_by_line'
       
     for_loop_statements = for_loop_statements.reject {|line| line.include?("forEach")}
 
-    puts for_loop_statements
-
     for_loop_statements.each do |statement|
 
       varis = statement.split("for (")[1].split(";",2)[0].split(",")

data/lib/nilac/lexical_scoped_function_variables.rb

@@ -0,0 +1,98 @@
+def lexical_scoped_variables(input_function_block)
+
+  #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\()/
+
+  variables = []
+
+  function_name, parameters = input_function_block[0].split("(")
+
+  parameters = parameters.split(")")[0].split(",")
+
+  parameters = parameters.collect { |element| element.strip }
+
+  input_function_block.each do |line|
+
+    if line.include? "=" and line.index(controlregexp).nil?
+
+      current_line_split = line.strip.split("=")
+
+      variables << current_line_split[0].rstrip
+
+    end
+
+  end
+
+  parameters.each do |param|
+
+    if variables.include?(param)
+
+      variables.delete(param)
+
+    end
+
+  end
+
+  if variables.empty?
+
+    return []
+
+  else
+
+    return variables.uniq.sort
+
+  end
+
+end

data/lib/nilac/pretty_print_javascript.rb

@@ -46,7 +46,7 @@ require_relative 'read_file_line_by_line'
 
       def extract_blocks(file_contents)
 
-        javascript_regexp = /(if |for |while |case |default:|switch\(|\(function\(|= function\(|function\(|((=|:)\s+\{))/
+        javascript_regexp = /(if |for |while |case |default:|switch\(|\(function\(|= function\(|,\s*function\(|((=|:)\s+\{))/
 
         block_starting_lines = file_contents.dup.reject { |element| element.index(javascript_regexp).nil? }[1..-1]
 
@@ -62,7 +62,9 @@ require_relative 'read_file_line_by_line'
 
         end
 
-        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].strip.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"))}
+
+        block_ending_lines = block_ending_lines.reject {|index| file_contents[index].include?("    ")}
 
         modified_file_contents = file_contents.dup
 
@@ -98,13 +100,13 @@ require_relative 'read_file_line_by_line'
 
           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
 

data/lib/nilac/version.rb

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

data/lib/nilac.rb

@@ -8,81 +8,44 @@ $LOAD_PATH << File.dirname(__FILE__)
 module Nilac
   
   require 'nilac/version'
-
   require 'fileutils'
-  
   require 'nilac/read_file_line_by_line'
-
   require 'nilac/find_file_name'
-
   require 'nilac/find_file_path'
-
   require 'nilac/extract_parsable_file'
-
   require 'nilac/compile_require_statements'
-
   require 'nilac/replace_multiline_comments'
-
   require 'nilac/split_semicolon_seperated_expressions'
-
   require 'nilac/compile_heredocs'
-
   require 'nilac/compile_interpolated_strings'
-
   require 'nilac/replace_singleline_comments'
-
   require 'nilac/replace_named_functions'
-
   require 'nilac/compile_parallel_assignment'
-
   require 'nilac/compile_default_values'
-
   require 'nilac/get_variables'
-
   require 'nilac/remove_question_marks'
-
   require 'nilac/compile_arrays'
-
   require 'nilac/compile_hashes'
-
   require 'nilac/compile_strings'
-
   require 'nilac/compile_integers'
-
   require 'nilac/compile_classes'
-
   require 'nilac/compile_named_functions'
-
   require 'nilac/compile_custom_function_map'
-
   require 'nilac/compile_ruby_methods'
-
   require 'nilac/compile_special_keywords'
-
   require 'nilac/compile_whitespace_delimited_functions'
-
   require 'nilac/compile_conditional_structures'
-
   require 'nilac/compile_case_statement'
-
   require 'nilac/compile_loops'
-
+  require 'nilac/compile_lambdas'
   require 'nilac/compile_blocks'
-
   require 'nilac/add_semicolons'
-
   require 'nilac/compile_comments'
-
   require 'nilac/pretty_print_javascript'
-
   require 'nilac/compile_operators'
-
   require 'nilac/output_javascript'
-
   require 'nilac/create_mac_executable'
-
   require 'nilac/parse_arguments'
-
   require 'nilac/compile_classes'
   
   class NilaCompiler
@@ -109,8 +72,6 @@ module Nilac
 
         file_contents = split_semicolon_seperated_expressions(file_contents)
 
-        compile_classes(file_contents)
-
         file_contents = compile_heredocs(file_contents, temp_file)
 
         file_contents,loop_vars = compile_loops(file_contents,temp_file)
@@ -123,6 +84,8 @@ module Nilac
 
         file_contents = compile_conditional_structures(file_contents, temp_file)
 
+        file_contents,lambda_names = compile_lambdas(file_contents,temp_file)
+
         file_contents = compile_blocks(file_contents,temp_file)
 
         file_contents = compile_integers(file_contents)
@@ -153,6 +116,8 @@ module Nilac
 
         function_names << ruby_functions
 
+        function_names << lambda_names
+
         list_of_variables += loop_vars
 
         file_contents = compile_whitespace_delimited_functions(file_contents, function_names, temp_file)
@@ -324,9 +289,7 @@ end
 if ARGV.include?("--test")
 
   ARGV.delete("--test")
-
   compiler = Nilac::NilaCompiler.new(ARGV)
-
   compiler.start_compile()
 
 end

data/shark/features/javascript_methods.feature

@@ -0,0 +1,11 @@
+Feature: This feature introduces .undefined?, .nil? and .exist? operators to help Javascript development.   
+  Scenario: Input file with different operators
+    Given the input file "javascript_methods.nila"
+    When the ~compiler is run
+    The output file must be "javascript_methods.js"
+    The output file must equal "correct_javascript_methods.js"
+
+Configurations:
+
+~compiler => lib/nilac.rb
+:v $cliusage => ruby :v --test --compile $file

data/shark/test_files/conditional_assignment.nila

@@ -0,0 +1,9 @@
+# This file demonstrates the conditional assignment operator in Nila
+
+a = nil
+b = 20
+a ||= b
+
+a = true
+b = 20
+a &&= b

data/shark/test_files/correct_conditional_assignment.js

@@ -0,0 +1,19 @@
+//Written using Nila. Visit http://adhithyan15.github.io/nila
+(function() {
+  var a, b;
+
+  // This file demonstrates the conditional assignment operator in Nila
+
+  a = null;
+
+  b = 20;
+
+  a  = a  ||  b;
+
+  a = true;
+
+  b = 20;
+
+  a  = a  &&  b;
+
+}).call(this);

data/shark/test_files/correct_javascript_methods.js

@@ -0,0 +1,25 @@
+//Written using Nila. Visit http://adhithyan15.github.io/nila
+(function() {
+  var commandline_args, overspeed;
+
+  if ((typeof console !== "undefined" && console !== null)) {
+    console.log("You can use console.log");
+  }
+
+  if ((typeof console !== "undefined" && console !== null)) {
+    console.log("You can use console.log");
+  }
+
+  commandline_args = ["-c"];
+
+  if ((typeof commandline_args[1] === "undefined")) {
+    console.log("Your second argument was empty!");
+  }
+
+  overspeed = null;
+
+  if ((overspeed === null)) {
+    console.log("No overspeeding vehicles found!");
+  }
+
+}).call(this);

data/shark/test_files/correct_required_module.js

@@ -1,9 +1,11 @@
 //Written using Nila. Visit http://adhithyan15.github.io/nila
 (function() {
-  var fs;
+  var fs, http;
 
   fs = require('fs');
 
+  http = require('http');
+
   fs.readFile('/etc/hosts','utf8',function(err,data) {
     if (err) {
       console.log(err);

data/shark/test_files/javascript_methods.nila

@@ -0,0 +1,19 @@
+puts "You can use console.log" if console.exist?
+
+puts "You can use console.log" if console.?
+
+commandline_args = %w{-c}
+
+if commandline_args[1].undefined?
+
+  puts "Your second argument was empty!"
+
+end
+
+overspeed = nil
+
+if overspeed.nil?
+
+  puts "No overspeeding vehicles found!"
+
+end

data/shark/test_files/lambda.nila

@@ -0,0 +1,8 @@
+square = -> {|num| num*num }
+
+l = lambda do |a, b|
+      tmp = a * 7
+      tmp * b / 50
+    end
+    
+puts square 5

data/shark/test_files/ternary.nila

@@ -0,0 +1,7 @@
+# This example was taken from http://alvinalexander.com/blog/post/ruby/examples-ruby-ternary-operator-true-false-syntax
+
+# set the speed
+speed = 90
+
+# somewhere later in the program ...
+speed > 55 ? (speed < 70 ? puts("Fine is $400") : puts("Fine is $800")) : puts("I'm a careful driver")

data/shark/test_files/variable_spaces.nila

@@ -0,0 +1,6 @@
+# An experiment to allow spaces in variable names. Inspired by Pogoscript (http://pogoscript.org)
+# The Nilac implementation is not complete. Again, this is just an experiment
+
+wind speed = 25
+
+average temperature = 32

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nilac
 version: !ruby/object:Gem::Version
-  version: 0.0.4.3.9.5
+  version: 0.0.4.3.9.6
 platform: ruby
 authors:
 - Adhithya Rajasekaran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-10 00:00:00.000000000 Z
+date: 2013-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shark
@@ -38,7 +38,6 @@ files:
 - README.md
 - Rakefile
 - bin/nilac
-- examples/StringMagic.nila
 - examples/countdown.nila
 - examples/decBin.js
 - examples/decBin.nila
@@ -46,6 +45,7 @@ files:
 - examples/marky.nila
 - lib/nilac.rb
 - lib/nilac/ErrorDeclarations.rb
+- lib/nilac/add_auto_return_statement.rb
 - lib/nilac/add_semicolons.rb
 - lib/nilac/compile_arrays.rb
 - lib/nilac/compile_blocks.rb
@@ -60,7 +60,9 @@ files:
 - lib/nilac/compile_heredocs.rb
 - lib/nilac/compile_integers.rb
 - lib/nilac/compile_interpolated_strings.rb
+- lib/nilac/compile_lambdas.rb
 - lib/nilac/compile_loops.rb
+- lib/nilac/compile_multiple_return.rb
 - lib/nilac/compile_named_functions.rb
 - lib/nilac/compile_operators.rb
 - lib/nilac/compile_parallel_assignment.rb
@@ -68,7 +70,6 @@ files:
 - lib/nilac/compile_ruby_methods.rb
 - lib/nilac/compile_special_keywords.rb
 - lib/nilac/compile_strings.rb
-- lib/nilac/compile_ternary_operator.rb
 - lib/nilac/compile_whitespace_delimited_functions.rb
 - lib/nilac/create_mac_executable.rb
 - lib/nilac/extract_parsable_file.rb
@@ -76,6 +77,7 @@ files:
 - lib/nilac/find_file_name.rb
 - lib/nilac/find_file_path.rb
 - lib/nilac/get_variables.rb
+- lib/nilac/lexical_scoped_function_variables.rb
 - lib/nilac/output_javascript.rb
 - lib/nilac/parse_arguments.rb
 - lib/nilac/pretty_print_javascript.rb
@@ -100,6 +102,7 @@ files:
 - shark/features/hashes.feature
 - shark/features/heredoc.feature
 - shark/features/if_then_else.feature
+- shark/features/javascript_methods.feature
 - shark/features/loop.feature
 - shark/features/method_multiple_return.feature
 - shark/features/multiline_array.feature
@@ -120,8 +123,10 @@ files:
 - shark/test_files/array_sugar.nila
 - shark/test_files/case.nila
 - shark/test_files/class.nila
+- shark/test_files/conditional_assignment.nila
 - shark/test_files/correct.js
 - shark/test_files/correct_case.js
+- shark/test_files/correct_conditional_assignment.js
 - shark/test_files/correct_default_parameters.js
 - shark/test_files/correct_for.js
 - shark/test_files/correct_hashes.js
@@ -129,6 +134,7 @@ files:
 - shark/test_files/correct_if_then_else.js
 - shark/test_files/correct_indexing.js
 - shark/test_files/correct_initialization.js
+- shark/test_files/correct_javascript_methods.js
 - shark/test_files/correct_loop.js
 - shark/test_files/correct_multiline_array.js
 - shark/test_files/correct_multiple_return.js
@@ -151,6 +157,8 @@ files:
 - shark/test_files/hashes.nila
 - shark/test_files/heredoc.nila
 - shark/test_files/if_then_else.nila
+- shark/test_files/javascript_methods.nila
+- shark/test_files/lambda.nila
 - shark/test_files/loop.nila
 - shark/test_files/multiline_array.nila
 - shark/test_files/multiple_initialization.nila
@@ -170,8 +178,10 @@ files:
 - shark/test_files/splats.nila
 - shark/test_files/string_interpolation.nila
 - shark/test_files/string_operators.nila
+- shark/test_files/ternary.nila
 - shark/test_files/times.nila
 - shark/test_files/unless_until.nila
+- shark/test_files/variable_spaces.nila
 - shark/test_files/whitespace_delimiter.nila
 homepage: http://adhithyan15.github.com/nila
 licenses: []

data/examples/StringMagic.nila

@@ -1,23 +0,0 @@
-# StringMagic is an implementation of Ruby's string methods in Javascript using Nila.
-# It extends the String prototype by adding more methods to it. 
-
-# It is being written by Adhithya Rajasekaran and Sri Madhavi Rajasekaran.
-
-# It is released under the MIT License
-
-# Nila allows you to open native Classes/Prototypes and extend them with custom
-# methods/functions. So we will be opening the String class and adding more methods
-# to it. 
-
-class String
-
-def endswith(suffix)
-
- # suffix can be any string
-
- self.include?(suffix,self.length-suffix.length)
-
-end
-
-
-end

data/lib/nilac/compile_ternary_operator.rb

@@ -1,6 +0,0 @@
-# This method compiles plain ternary operators into equivalent Javascript code
-
-def compile_ternary_operator(input_file_contents)
-
-
-end