nilac 0.0.4.3.9.1 → 0.0.4.3.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e0d46d6d6e2aaa881ffb278fbc8f238936e7864
-  data.tar.gz: ee0597f8e948fe0b0822c5ccde1c0143c06b4c18
+  metadata.gz: 8cec9f92a950d69f17f9a9e5d2fc2e240bffa540
+  data.tar.gz: 5c4ab209155e48ad3c44c934e7abfbe9d6d5e82b
 SHA512:
-  metadata.gz: da6a215afb5a19e75ad26820acb0c98fdcece13e511fee35a194e5448485301d13ed990966db651b5edfb40b92c06a09da0b9e5fca249fcf9323132f617c8fa9
-  data.tar.gz: e22a907ec7aa2f7a776a9c41dc4de56056cec67c5ae299c300074197a1b7120326a491137cd093784ce110937baf02a3c913fe34f946fb6235f4b6d734bceccf
+  metadata.gz: c0508eff8f8d817ece1ea7c4359cd87f9135db0dad59cd399d6b1e5d664673bc2981bed328721108ecac990289d930ffc7b8eb280f6e5db7e4c1c40cd4a5b74c
+  data.tar.gz: fa3284945a8f4564e1e4611b3d6678d28808650d009fbda5472bfa356cf81d2a3d866e980f83ff933a8d054282301ac8de8c4f07b4733f0d7e8cb4ca771b4223

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.idea

data/bin/nilac

@@ -8,6 +8,20 @@
 require 'slop'
 require 'fileutils'
 
+# The following are error classes used by Nilac to give you detailed error information
+
+class ParseError < RuntimeError
+
+  def initialize(message)
+
+    puts "ParseError: " + message
+
+    abort
+
+  end
+
+end
+
 
 def compile(input_file_path, *output_file_name)
 
@@ -784,6 +798,39 @@ def compile(input_file_path, *output_file_name)
     #   puts "Filling the #{container} with #{liquid}"
     # end
 
+    def errorFree(function_params)
+
+      # This method checks for use cases in complex arguments where a default argument is used
+      # after an optional argument. This will result in erroneous output. So this method will
+      # stop it from happening.
+
+      # Example:
+      # def method_name(a,b,*c,d = 1,c,e)
+
+      optional_param = function_params.reject {|element| !replace_strings(element).include?("*")}[0]
+
+      unless optional_param.nil?
+
+        after_splat = function_params[function_params.index(optional_param)+1..-1]
+
+        if after_splat.reject {|element| !element.include?("=")}.empty?
+
+          true
+
+        else
+
+          ParseError.new("You cannot have default argument after an optional argument! Change the following usage!\n#{function_params.join(",")}")
+
+        end
+
+      else
+
+        true
+
+      end
+
+    end
+
     def parse_default_values(input_function_definition)
 
       split1, split2 = input_function_definition.split("(")
@@ -792,23 +839,27 @@ def compile(input_file_path, *output_file_name)
 
       function_parameters = split2.split(",")
 
-      default_value_parameters = function_parameters.reject { |element| !element.include? "=" }
+      if errorFree(function_parameters)
 
-      replacement_parameters = []
+        default_value_parameters = function_parameters.reject { |element| !element.include? "=" }
 
-      replacement_string = ""
+        replacement_parameters = []
 
-      default_value_parameters.each do |paramvalue|
+        replacement_string = ""
 
-        param, value = paramvalue.split("=")
+        default_value_parameters.each do |paramvalue|
 
-        replacement_parameters << param.lstrip.rstrip
+          param, value = paramvalue.split("=")
 
-        replacement_string = replacement_string + "\n" + "if (#{param.lstrip.rstrip} equequ null) {\n  #{paramvalue.lstrip.rstrip}\n}\n" +"\n"
+          replacement_parameters << param.lstrip.rstrip
 
-      end
+          replacement_string = replacement_string + "\n" + "if (#{param.lstrip.rstrip} equequ null) {\n  #{paramvalue.lstrip.rstrip}\n}\n" +"\n"
 
-      return replacement_string, default_value_parameters, replacement_parameters
+        end
+
+        return replacement_string, default_value_parameters, replacement_parameters
+
+      end
 
     end
 
@@ -858,7 +909,7 @@ def compile(input_file_path, *output_file_name)
 
         input_file_contents[current_line_index] = modified_line
 
-        input_file_contents[current_line_index + 1] = replacement_string
+        input_file_contents.insert(current_line_index+1,replacement_string)
 
       end
 
@@ -1840,7 +1891,7 @@ def compile(input_file_path, *output_file_name)
 
       else
 
-        return variables.uniq
+        return variables.uniq.sort
 
       end
 
@@ -1882,6 +1933,8 @@ def compile(input_file_path, *output_file_name)
 
         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]
 
         if !rejected_array[0].strip.eql?("}")
@@ -2106,6 +2159,16 @@ def compile(input_file_path, *output_file_name)
 
       modified_input_array = compile_parallel_assignment(modified_input_array, temporary_nila_file)
 
+      modified_input_array = compile_multiple_ruby_func_calls(modified_input_array)
+
+      modified_input_array = add_auto_return_statement(modified_input_array)
+
+      modified_input_array = compile_multiple_return(modified_input_array)
+
+      modified_input_array = coffee_type_function(modified_input_array)
+
+      modified_input_array = compile_splats(modified_input_array)
+
       variables = lexical_scoped_variables(modified_input_array)
 
       if !variables.empty?
@@ -2118,12 +2181,6 @@ def compile(input_file_path, *output_file_name)
 
       modified_input_array = remove_question_marks(modified_input_array, variables, temporary_nila_file)
 
-      modified_input_array = add_auto_return_statement(modified_input_array)
-
-      modified_input_array = compile_multiple_return(modified_input_array)
-
-      modified_input_array = coffee_type_function(modified_input_array)
-
       return modified_input_array
 
     end
@@ -2148,6 +2205,237 @@ def compile(input_file_path, *output_file_name)
 
     end
 
+    def compile_splats(input_function_block)
+
+      def strToArray(input_string)
+
+        file_id = File.new('hello.nila','w')
+
+        file_id.write(input_string)
+
+        file_id.close()
+
+        line_by_line_contents = read_file_line_by_line('hello.nila')
+
+        File.delete(file_id)
+
+        return line_by_line_contents
+
+      end
+
+      def errorFree(function_params,optional_param)
+
+        # This method checks for use cases in complex arguments where a default argument is used
+        # after an optional argument. This will result in erroneous output. So this method will
+        # stop it from happening.
+
+        # Example:
+        # def method_name(a,b,*c,d = 1,c,e)
+
+        after_splat = function_params[function_params.index(optional_param)+1..-1]
+
+        if after_splat.reject {|element| !element.include?("=")}.empty?
+
+          true
+
+        else
+
+          raise "You cannot have a default argument after an optional argument!"
+
+          false
+
+        end
+
+      end
+
+      function_params = input_function_block[0].split("function(")[1].split(")")[0].split(",")
+
+      unless function_params.reject{|element| !replace_strings(element).include?("*")}.empty?
+
+        mod_function_params = function_params.reject {|element| replace_strings(element).include?("*")}
+
+        opt_index = 0
+
+        # If there are multiple optional params declared by mistake, only the first optional param is used.
+
+        optional_param = function_params.reject {|element| !replace_strings(element).include?("*")}[0]
+
+        if function_params.index(optional_param).eql?(function_params.length-1)
+
+          mod_function_params.each_with_index do |param,index|
+
+            input_function_block.insert(index+1,"#{param} = arguments[#{index}]\n\n")
+
+            opt_index = index + 1
+
+          end
+
+          replacement_string = "#{optional_param.gsub("*","")} = []\n\n"
+
+          replacement_string += "for (var i=#{opt_index};i<arguments.length;i++) {\n #{optional_param.gsub("*","")}.push(arguments[i]); \n}\n\n"
+
+          input_function_block.insert(opt_index+1,replacement_string)
+
+          input_function_block[0] = input_function_block[0].sub(function_params.join(","),"")
+
+        else
+
+          before_splat = function_params[0...function_params.index(optional_param)]
+
+          after_splat = function_params[function_params.index(optional_param)+1..-1]
+
+          cont_index = 0
+
+          if errorFree(function_params,optional_param)
+
+            before_splat.each_with_index do |param,index|
+
+              input_function_block.insert(index+1,"#{param} = arguments[#{index}]\n\n")
+
+              cont_index = index + 1
+
+            end
+
+            after_splat.each_with_index do |param,index|
+
+              input_function_block.insert(cont_index+1,"#{param} = arguments[arguments.length-#{after_splat.length - index}]\n\n")
+
+              cont_index = cont_index + 1
+
+            end
+
+            replacement_string = "#{optional_param.gsub("*","")} = []\n\n"
+
+            replacement_string += "for (var i=#{function_params.index(optional_param)};i < arguments.length-#{after_splat.length};i++) {\n #{optional_param.gsub("*","")}.push(arguments[i]); \n}\n\n"
+
+            input_function_block.insert(cont_index+1,replacement_string)
+
+            input_function_block[0] = input_function_block[0].sub(function_params.join(","),"")
+
+          end
+
+        end
+
+      end
+
+      return strToArray(input_function_block.join)
+
+    end
+
+    def compile_multiple_ruby_func_calls(input_file_contents)
+
+      def strToArray(input_string)
+
+        file_id = File.new('hello.nila','w')
+
+        file_id.write(input_string)
+
+        file_id.close()
+
+        line_by_line_contents = read_file_line_by_line('hello.nila')
+
+        File.delete(file_id)
+
+        return line_by_line_contents
+
+      end
+
+      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
+
+        input_string = input_string.gsub(/\((\w{0,},)*\w{0,}\)/,"--$k$")
+
+        return input_string
+
+      end
+
+      function_calls = []
+
+      replacement_calls = []
+
+      function_map = %w{puts p print}
+
+      javascript_regexp = /(if |for |while |\(function\(|= function\(|((=|:)\s+\{))/
+
+      stringified_input = input_file_contents.collect {|element| replace_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)}
+
+        modified_func_calls = modified_func_calls.reject {|element| !element.include?(",")}
+
+        call_collector = []
+
+        modified_func_calls.each_with_index do |ele|
+
+          call_collector << input_file_contents[stringified_input.index(ele)]
+
+        end
+
+        function_calls << modified_func_calls
+
+        rep_calls = []
+
+        call_collector.each do |fcall|
+
+          multiple_call = fcall.split(func)[1].split(",")
+
+          multiple_call = multiple_call.collect {|element| "\n#{func} " + element.strip + "\n\n"}
+
+          rep_calls << multiple_call.join
+
+        end
+
+        replacement_calls << rep_calls
+
+      end
+
+      replacement_calls = replacement_calls.flatten
+
+      function_calls = function_calls.flatten
+
+      function_calls.each_with_index do |fcall,index|
+
+        input_file_contents[stringified_input.index(fcall)] = replacement_calls[index]
+
+      end
+
+      return strToArray(input_file_contents.join)
+
+    end
+
     joined_file_contents = input_file_contents.join
 
     unless named_code_blocks.empty?
@@ -2190,7 +2478,7 @@ def compile(input_file_path, *output_file_name)
 
     file_id.close()
 
-    line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+    line_by_line_contents = compile_multiple_ruby_func_calls(read_file_line_by_line(temporary_nila_file))
 
     return line_by_line_contents, function_names
 
@@ -2446,6 +2734,8 @@ def compile(input_file_path, *output_file_name)
 
             modified_string = modified_string.sub(function+" ", function+"(")
 
+            modified_string = modified_string.split("#{function}(")[0] + "#{function}(" + modified_string.split("#{function}(")[1].lstrip
+
             modified_string = modified_string.sub("\n", ")\n")
 
             joined_file_contents = joined_file_contents.sub(string, modified_string)

data/lib/nilac/version.rb

@@ -1,3 +1,3 @@
 module Nilac
-  VERSION = "0.0.4.3.9.1"
+  VERSION = "0.0.4.3.9.2"
 end

data/shark/features/splats.feature

@@ -0,0 +1,11 @@
+Feature: This feature brings powerful Splat arguments for Methods/Functions    
+  Scenario: Input file with multiple splats parameters for methods/functions
+    Given the input file "splats.nila"
+    When the ~compiler is run
+    The output file must be "splats.js"
+    The output file must equal "correct_splats.js"
+
+Configurations:
+
+~compiler => src/nilac.rb
+:v $cliusage => ruby :v --compile $file

data/shark/test_files/case.nila

@@ -6,7 +6,7 @@ case grade
 when "A", "B"
   puts 'You are pretty smart!'
 when "C"
-  puts 'You are intelligent!'
+  puts 'You are reasonably intelligent!'
 end
 
 end

data/shark/test_files/correct_case.js

@@ -14,7 +14,7 @@
         console.log('You are pretty smart!');
         break;
       case "C":
-        console.log('You are intelligent!');
+        console.log('You are reasonably intelligent!');
         break;
     }
   }

data/shark/test_files/correct_splats.js

@@ -0,0 +1,89 @@
+//Written using Nila. Visit http://adhithyan15.github.io/nila
+(function() {
+  var args_unleashed, default_args, mixed_args, two_or_more;
+
+  // These example were taken from The Well Grounded Rubyist by Manning
+
+  // Copyright: Manning Publications
+
+  two_or_more = function() {
+    var a, b, c;
+    a = arguments[0];
+    b = arguments[1];
+    c = [];
+    for (var i=2;i<arguments.length;i++) {
+      c.push(arguments[i]); 
+    }
+    console.log("I require two or more arguments!");
+    console.log("And sure enough, I got: ");
+    console.log(a);
+    console.log(b);
+    return console.log(c);
+  };
+
+  two_or_more(1,2,3,4,5);
+
+  default_args = function(a,b,c) {
+    if (c == null) {
+      c = 1;
+    }
+    console.log("Values of variables: ");
+    console.log(a);
+    console.log(b);
+    return console.log(c);
+  };
+
+  default_args(3,2);
+
+  default_args(4,5,6);
+
+  mixed_args = function() {
+    var a, b, c, d, e, f;
+    a = arguments[0];
+    b = arguments[1];
+    c = arguments[2];
+    e = arguments[arguments.length-2];
+    f = arguments[arguments.length-1];
+    d = [];
+    for (var i=3;i < arguments.length-2;i++) {
+      d.push(arguments[i]); 
+    }
+    console.log("Arguments:");
+    console.log(a);
+    console.log(b);
+    console.log(c);
+    console.log(d);
+    console.log(e);
+    return console.log(f);
+  };
+
+  mixed_args(0,1,2,3,4,5,6,7,8);
+
+  args_unleashed = function() {
+    var a, b, c, d, e;
+    a = arguments[0];
+    b = arguments[1];
+    d = arguments[arguments.length-2];
+    e = arguments[arguments.length-1];
+    c = [];
+    for (var i=2;i < arguments.length-2;i++) {
+      c.push(arguments[i]); 
+    }
+    if (b == null) {
+      b=1;
+    }
+    console.log("Arguments:");
+    console.log(a);
+    console.log(b);
+    console.log(c);
+    console.log(d);
+    return console.log(e);
+  };
+
+  args_unleashed(1,2,3,4,5);
+
+  args_unleashed(1,2,3,4);
+
+  args_unleashed(1,2,3,4,5,6,7,8);
+
+}).call(this);

data/shark/test_files/splats.nila

@@ -0,0 +1,36 @@
+# These example were taken from The Well Grounded Rubyist by Manning
+# Copyright: Manning Publications
+
+def two_or_more(a,b,*c)
+  puts "I require two or more arguments!"
+  puts "And sure enough, I got: "
+  puts a, b, c
+end
+
+two_or_more 1,2,3,4,5
+
+def default_args(a,b,c = 1)
+  puts "Values of variables: ",a,b,c
+end
+
+default_args 3,2
+
+default_args 4,5,6
+
+def mixed_args(a,b,c,*d,e,f)
+  puts "Arguments:"
+  puts a,b,c,d,e,f
+end
+
+mixed_args(0,1,2,3,4,5,6,7,8)
+
+def args_unleashed(a,b=1,*c,d,e)
+  puts "Arguments:"
+  p a,b,c,d,e
+end
+
+args_unleashed(1,2,3,4,5)
+
+args_unleashed(1,2,3,4)
+
+args_unleashed(1,2,3,4,5,6,7,8)

data/src/nilac.rb

@@ -6,6 +6,20 @@
 require 'slop'
 require 'fileutils'
 
+# The following are error classes used by Nilac to give you detailed error information
+
+class ParseError < RuntimeError
+
+  def initialize(message)
+
+    puts "ParseError: " + message
+
+    abort
+
+  end
+
+end
+
 
 def compile(input_file_path, *output_file_name)
 
@@ -782,6 +796,39 @@ def compile(input_file_path, *output_file_name)
     #   puts "Filling the #{container} with #{liquid}"
     # end
 
+    def errorFree(function_params)
+
+      # This method checks for use cases in complex arguments where a default argument is used
+      # after an optional argument. This will result in erroneous output. So this method will
+      # stop it from happening.
+
+      # Example:
+      # def method_name(a,b,*c,d = 1,c,e)
+
+      optional_param = function_params.reject {|element| !replace_strings(element).include?("*")}[0]
+
+      unless optional_param.nil?
+
+        after_splat = function_params[function_params.index(optional_param)+1..-1]
+
+        if after_splat.reject {|element| !element.include?("=")}.empty?
+
+          true
+
+        else
+
+          ParseError.new("You cannot have default argument after an optional argument! Change the following usage!\n#{function_params.join(",")}")
+
+        end
+
+      else
+
+        true
+
+      end
+
+    end
+
     def parse_default_values(input_function_definition)
 
       split1, split2 = input_function_definition.split("(")
@@ -790,23 +837,27 @@ def compile(input_file_path, *output_file_name)
 
       function_parameters = split2.split(",")
 
-      default_value_parameters = function_parameters.reject { |element| !element.include? "=" }
+      if errorFree(function_parameters)
 
-      replacement_parameters = []
+        default_value_parameters = function_parameters.reject { |element| !element.include? "=" }
 
-      replacement_string = ""
+        replacement_parameters = []
 
-      default_value_parameters.each do |paramvalue|
+        replacement_string = ""
 
-        param, value = paramvalue.split("=")
+        default_value_parameters.each do |paramvalue|
 
-        replacement_parameters << param.lstrip.rstrip
+          param, value = paramvalue.split("=")
 
-        replacement_string = replacement_string + "\n" + "if (#{param.lstrip.rstrip} equequ null) {\n  #{paramvalue.lstrip.rstrip}\n}\n" +"\n"
+          replacement_parameters << param.lstrip.rstrip
 
-      end
+          replacement_string = replacement_string + "\n" + "if (#{param.lstrip.rstrip} equequ null) {\n  #{paramvalue.lstrip.rstrip}\n}\n" +"\n"
 
-      return replacement_string, default_value_parameters, replacement_parameters
+        end
+
+        return replacement_string, default_value_parameters, replacement_parameters
+
+      end
 
     end
 
@@ -856,7 +907,7 @@ def compile(input_file_path, *output_file_name)
 
         input_file_contents[current_line_index] = modified_line
 
-        input_file_contents[current_line_index + 1] = replacement_string
+        input_file_contents.insert(current_line_index+1,replacement_string)
 
       end
 
@@ -1838,7 +1889,7 @@ def compile(input_file_path, *output_file_name)
 
       else
 
-        return variables.uniq
+        return variables.uniq.sort
 
       end
 
@@ -1880,6 +1931,8 @@ def compile(input_file_path, *output_file_name)
 
         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]
 
         if !rejected_array[0].strip.eql?("}")
@@ -2104,6 +2157,16 @@ def compile(input_file_path, *output_file_name)
 
       modified_input_array = compile_parallel_assignment(modified_input_array, temporary_nila_file)
 
+      modified_input_array = compile_multiple_ruby_func_calls(modified_input_array)
+
+      modified_input_array = add_auto_return_statement(modified_input_array)
+
+      modified_input_array = compile_multiple_return(modified_input_array)
+
+      modified_input_array = coffee_type_function(modified_input_array)
+
+      modified_input_array = compile_splats(modified_input_array)
+
       variables = lexical_scoped_variables(modified_input_array)
 
       if !variables.empty?
@@ -2116,12 +2179,6 @@ def compile(input_file_path, *output_file_name)
 
       modified_input_array = remove_question_marks(modified_input_array, variables, temporary_nila_file)
 
-      modified_input_array = add_auto_return_statement(modified_input_array)
-
-      modified_input_array = compile_multiple_return(modified_input_array)
-
-      modified_input_array = coffee_type_function(modified_input_array)
-
       return modified_input_array
 
     end
@@ -2146,6 +2203,237 @@ def compile(input_file_path, *output_file_name)
 
     end
 
+    def compile_splats(input_function_block)
+
+      def strToArray(input_string)
+
+        file_id = File.new('hello.nila','w')
+
+        file_id.write(input_string)
+
+        file_id.close()
+
+        line_by_line_contents = read_file_line_by_line('hello.nila')
+
+        File.delete(file_id)
+
+        return line_by_line_contents
+
+      end
+
+      def errorFree(function_params,optional_param)
+
+        # This method checks for use cases in complex arguments where a default argument is used
+        # after an optional argument. This will result in erroneous output. So this method will
+        # stop it from happening.
+
+        # Example:
+        # def method_name(a,b,*c,d = 1,c,e)
+
+        after_splat = function_params[function_params.index(optional_param)+1..-1]
+
+        if after_splat.reject {|element| !element.include?("=")}.empty?
+
+          true
+
+        else
+
+          raise "You cannot have a default argument after an optional argument!"
+
+          false
+
+        end
+
+      end
+
+      function_params = input_function_block[0].split("function(")[1].split(")")[0].split(",")
+
+      unless function_params.reject{|element| !replace_strings(element).include?("*")}.empty?
+
+        mod_function_params = function_params.reject {|element| replace_strings(element).include?("*")}
+
+        opt_index = 0
+
+        # If there are multiple optional params declared by mistake, only the first optional param is used.
+
+        optional_param = function_params.reject {|element| !replace_strings(element).include?("*")}[0]
+
+        if function_params.index(optional_param).eql?(function_params.length-1)
+
+          mod_function_params.each_with_index do |param,index|
+
+            input_function_block.insert(index+1,"#{param} = arguments[#{index}]\n\n")
+
+            opt_index = index + 1
+
+          end
+
+          replacement_string = "#{optional_param.gsub("*","")} = []\n\n"
+
+          replacement_string += "for (var i=#{opt_index};i<arguments.length;i++) {\n #{optional_param.gsub("*","")}.push(arguments[i]); \n}\n\n"
+
+          input_function_block.insert(opt_index+1,replacement_string)
+
+          input_function_block[0] = input_function_block[0].sub(function_params.join(","),"")
+
+        else
+
+          before_splat = function_params[0...function_params.index(optional_param)]
+
+          after_splat = function_params[function_params.index(optional_param)+1..-1]
+
+          cont_index = 0
+
+          if errorFree(function_params,optional_param)
+
+            before_splat.each_with_index do |param,index|
+
+              input_function_block.insert(index+1,"#{param} = arguments[#{index}]\n\n")
+
+              cont_index = index + 1
+
+            end
+
+            after_splat.each_with_index do |param,index|
+
+              input_function_block.insert(cont_index+1,"#{param} = arguments[arguments.length-#{after_splat.length - index}]\n\n")
+
+              cont_index = cont_index + 1
+
+            end
+
+            replacement_string = "#{optional_param.gsub("*","")} = []\n\n"
+
+            replacement_string += "for (var i=#{function_params.index(optional_param)};i < arguments.length-#{after_splat.length};i++) {\n #{optional_param.gsub("*","")}.push(arguments[i]); \n}\n\n"
+
+            input_function_block.insert(cont_index+1,replacement_string)
+
+            input_function_block[0] = input_function_block[0].sub(function_params.join(","),"")
+
+          end
+
+        end
+
+      end
+
+      return strToArray(input_function_block.join)
+
+    end
+
+    def compile_multiple_ruby_func_calls(input_file_contents)
+
+      def strToArray(input_string)
+
+        file_id = File.new('hello.nila','w')
+
+        file_id.write(input_string)
+
+        file_id.close()
+
+        line_by_line_contents = read_file_line_by_line('hello.nila')
+
+        File.delete(file_id)
+
+        return line_by_line_contents
+
+      end
+
+      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
+
+        input_string = input_string.gsub(/\((\w{0,},)*\w{0,}\)/,"--$k$")
+
+        return input_string
+
+      end
+
+      function_calls = []
+
+      replacement_calls = []
+
+      function_map = %w{puts p print}
+
+      javascript_regexp = /(if |for |while |\(function\(|= function\(|((=|:)\s+\{))/
+
+      stringified_input = input_file_contents.collect {|element| replace_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)}
+
+        modified_func_calls = modified_func_calls.reject {|element| !element.include?(",")}
+
+        call_collector = []
+
+        modified_func_calls.each_with_index do |ele|
+
+          call_collector << input_file_contents[stringified_input.index(ele)]
+
+        end
+
+        function_calls << modified_func_calls
+
+        rep_calls = []
+
+        call_collector.each do |fcall|
+
+          multiple_call = fcall.split(func)[1].split(",")
+
+          multiple_call = multiple_call.collect {|element| "\n#{func} " + element.strip + "\n\n"}
+
+          rep_calls << multiple_call.join
+
+        end
+
+        replacement_calls << rep_calls
+
+      end
+
+      replacement_calls = replacement_calls.flatten
+
+      function_calls = function_calls.flatten
+
+      function_calls.each_with_index do |fcall,index|
+
+        input_file_contents[stringified_input.index(fcall)] = replacement_calls[index]
+
+      end
+
+      return strToArray(input_file_contents.join)
+
+    end
+
     joined_file_contents = input_file_contents.join
 
     unless named_code_blocks.empty?
@@ -2188,7 +2476,7 @@ def compile(input_file_path, *output_file_name)
 
     file_id.close()
 
-    line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+    line_by_line_contents = compile_multiple_ruby_func_calls(read_file_line_by_line(temporary_nila_file))
 
     return line_by_line_contents, function_names
 
@@ -2444,6 +2732,8 @@ def compile(input_file_path, *output_file_name)
 
             modified_string = modified_string.sub(function+" ", function+"(")
 
+            modified_string = modified_string.split("#{function}(")[0] + "#{function}(" + modified_string.split("#{function}(")[1].lstrip
+
             modified_string = modified_string.sub("\n", ")\n")
 
             joined_file_contents = joined_file_contents.sub(string, modified_string)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nilac
 version: !ruby/object:Gem::Version
-  version: 0.0.4.3.9.1
+  version: 0.0.4.3.9.2
 platform: ruby
 authors:
 - Adhithya Rajasekaran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-06 00:00:00.000000000 Z
+date: 2013-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shark
@@ -76,6 +76,7 @@ files:
 - shark/features/regular_while.feature
 - shark/features/ruby_methods.feature
 - shark/features/ruby_operators.feature
+- shark/features/splats.feature
 - shark/features/string_interpolation.feature
 - shark/features/strings.feature
 - shark/features/times.feature
@@ -102,6 +103,7 @@ files:
 - shark/test_files/correct_return.js
 - shark/test_files/correct_ruby_methods.js
 - shark/test_files/correct_single_return.js
+- shark/test_files/correct_splats.js
 - shark/test_files/correct_string_interpolation.js
 - shark/test_files/correct_string_operators.js
 - shark/test_files/correct_times.js
@@ -126,6 +128,7 @@ files:
 - shark/test_files/ruby_methods.nila
 - shark/test_files/simple.nila
 - shark/test_files/single_return.nila
+- shark/test_files/splats.nila
 - shark/test_files/string_interpolation.nila
 - shark/test_files/string_operators.nila
 - shark/test_files/times.nila