nilac 0.0.4.3.9.2 → 0.0.4.3.9.3

data/examples/StringMagic.nila

@@ -0,0 +1,23 @@
+# 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/examples/countdown.nila

@@ -0,0 +1,31 @@
+def countdown(minutes)
+
+  seconds = 60
+	
+	mins = minutes
+	
+	def tick
+	 
+	  counter = document.getElementById("counter")
+		
+		current_minutes = mins-1
+		
+		seconds--
+		
+		counter.innerHTML = "#{current_minutes.to_s}:#{if seconds < 10 then "0" else ""}#{String(seconds)}"
+		
+		if seconds > 0
+		
+		  setTimeout(tick,1000)
+			
+		else
+		
+		  countdown(mins - 1)  if mins > 1
+		
+		end
+		
+	end
+  
+	tick()
+	
+end

data/examples/decBin.nila

@@ -45,7 +45,7 @@ def decimalToBinary(input_num)
  
   calc = decimalplaces * 2
   
-  decans = calc.to_s[0];
+  decans = calc.to_s[0]
   
   decimalplaces = parseFloat("0.#{calc.to_s[2..last]}")
   
@@ -57,8 +57,8 @@ def decimalToBinary(input_num)
 
 end
 
-process.stdin.resume();
-process.stdin.setEncoding('utf8');
+process.stdin.resume()
+process.stdin.setEncoding('utf8')
 process.stdin.on 'data', do |chunk|
  print "Answer: #{decimalToBinary(chunk).join("")} \n\n"
 end

data/examples/marky.js

@@ -0,0 +1,30 @@
+//Written using Nila. Visit http://adhithyan15.github.io/nila
+(function() {
+  var commandline_args, parse_markdown;
+
+  // Marky is a simple markdown parser written in Nila and runs on Nodejs. 
+
+  // This will demonstrate the power and expressiveness of Nila. We will also 
+
+  // provide the Ruby version of the parser so that you can see how easy it
+
+  // is to port code from Ruby to Javascript using Nila
+
+  // This parser was written by Sri Madhavi Rajasekaran and is released under
+
+  // the MIT License.
+
+  // If you want to learn more about Nila, please visit http://adhithyan15.github.io/nila
+
+  parse_markdown = function() {
+  };
+
+  commandline_args = [];
+
+  process.argv.forEach(function(val,index,array) {
+    commandline_args.push(val);
+  });
+
+  console.log(commandline_args.slice(2));
+
+}).call(this);

data/examples/marky.nila

@@ -0,0 +1,23 @@
+# Marky is a simple markdown parser written in Nila and runs on Nodejs. 
+# This will demonstrate the power and expressiveness of Nila. We will also 
+# provide the Ruby version of the parser so that you can see how easy it
+# is to port code from Ruby to Javascript using Nila
+
+# This parser was written by Sri Madhavi Rajasekaran and is released under
+# the MIT License.
+
+# If you want to learn more about Nila, please visit http://adhithyan15.github.io/nila
+
+def parse_markdown
+
+end
+
+commandline_args = []
+
+process.argv.forEach do |val,index,array|
+
+  commandline_args << val
+
+end
+
+puts commandline_args[2..last]

data/lib/nilac/ErrorDeclarations.rb

@@ -0,0 +1,11 @@
+class NilaSyntaxError < RuntimeError
+
+  def initialize(message)
+
+    puts "SyntaxError: " + message
+
+    abort
+
+  end
+
+end

data/lib/nilac/add_semicolons.rb

@@ -0,0 +1,57 @@
+  def add_semicolons(input_file_contents)
+
+    def comment(input_string)
+
+      if input_string.include?("--single_line_comment")
+
+        true
+
+      elsif input_string.include?("--multiline_comment")
+
+        true
+
+      else
+
+        false
+
+      end
+
+    end
+
+    reject_regexp = /(function |Euuf |if |else|elsuf|switch |case|while |whaaleskey |for )/
+
+    modified_file_contents = input_file_contents.dup
+
+    input_file_contents.each_with_index do |line,index|
+
+      if line.index(reject_regexp) == nil
+
+        if !comment(line)
+
+          if !line.lstrip.eql?("")
+
+            if !line.lstrip.eql?("}\n")
+
+              if !line.lstrip.eql?("}\n\n")
+
+                if line.rstrip[-1] != "[" and line.rstrip[-1] != "{" and line.rstrip[-1] != "," and line.rstrip[-1] != ";"
+
+                  modified_file_contents[index] = line.rstrip + ";\n\n"
+
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+    modified_file_contents
+
+  end

data/lib/nilac/compile_arrays.rb

@@ -0,0 +1,266 @@
+require_relative 'find_all_matching_indices'
+
+require_relative 'read_file_line_by_line'
+
+  def compile_arrays(input_file_contents, named_functions, temporary_nila_file)
+
+    def compile_w_arrays(input_file_contents)
+
+      def extract(input_string, pattern_start, pattern_end)
+        
+        all_start_locations = find_all_matching_indices(input_string, pattern_start)
+
+        all_end_locations = find_all_matching_indices(input_string, pattern_end)
+
+        pattern = []
+
+        all_start_locations.each_with_index do |location, index|
+
+          pattern << input_string[location..all_end_locations[index]]
+
+        end
+
+        return pattern
+
+      end
+
+      def compile_w_syntax(input_string)
+
+        modified_input_string = input_string[3...-1]
+
+        string_split = modified_input_string.split(" ")
+
+        return string_split.to_s
+
+      end
+
+      modified_file_contents = input_file_contents.dup
+
+      input_file_contents.each_with_index do |line, index|
+
+        if line.include?("%w{")
+
+          string_arrays = extract(line, "%w{", "}")
+
+          string_arrays.each do |array|
+
+            modified_file_contents[index] = modified_file_contents[index].sub(array, compile_w_syntax(array))
+
+          end
+
+        end
+
+      end
+
+      return modified_file_contents
+
+    end
+
+    def compile_array_indexing(input_file_contents)
+
+      possible_indexing_operation = input_file_contents.dup.reject { |element| !element.include? "[" and !element.include? "]" }
+
+      possible_range_indexing = possible_indexing_operation.reject { |element| !element.include? ".." }
+
+      triple_range_indexing = possible_range_indexing.reject { |element| !element.include? "..." }
+
+      triple_range_indexes = []
+
+      triple_range_indexing.each do |line|
+
+        triple_range_indexes << input_file_contents.dup.each_index.select { |index| input_file_contents[index] == line }
+
+      end
+
+      triple_range_indexes = triple_range_indexes.flatten
+
+      triple_range_indexing.each_with_index do |line, index|
+
+        split1, split2 = line.split("[")
+
+        range_index, split3 = split2.split("]")
+
+        index_start, index_end = range_index.split "..."
+
+        replacement_string = nil
+
+        if index_end.strip == "last"
+
+          replacement_string = split1 + ".slice(#{index_start},#{split}.length)\n"
+
+        else
+
+          replacement_string = split1 + ".slice(#{index_start},#{index_end})\n"
+
+        end
+
+        possible_range_indexing.delete(input_file_contents[triple_range_indexes[index]])
+
+        possible_indexing_operation.delete(input_file_contents[triple_range_indexes[index]])
+
+        input_file_contents[triple_range_indexes[index]] = replacement_string
+
+      end
+
+      double_range_indexing = possible_range_indexing.reject { |element| !element.include?("..") }
+
+      double_range_indexes = []
+
+      double_range_indexing.each do |line|
+
+        double_range_indexes << input_file_contents.dup.each_index.select { |index| input_file_contents[index] == line }
+
+      end
+
+      double_range_indexes = double_range_indexes.flatten
+      
+      double_range_indexing.each_with_index do |line, index|
+
+        split1, split2 = line.split("[")
+
+        range_index, split3 = split2.split("]")
+
+        index_start, index_end = range_index.split ".."
+
+        index_start = "" if index_start.nil?
+
+        index_end = "" if index_end.nil?
+          
+        split3 = "" if split3.nil?
+
+        replacement_string = nil
+
+        if index_end.strip == "last"
+
+          replacement_string = split1 + ".slice(#{index_start})" + split3.strip + "\n\n"
+
+        elsif index_end.strip == "" and index_start.strip == ""
+
+          replacement_string = split1 + ".slice(0)\n"
+
+        else
+
+          replacement_string = split1 + ".slice(#{index_start},#{index_end}+1)\n"
+
+        end
+
+        possible_range_indexing.delete(input_file_contents[double_range_indexes[index]])
+
+        possible_indexing_operation.delete(input_file_contents[double_range_indexes[index]])
+
+        input_file_contents[double_range_indexes[index]] = replacement_string
+
+      end
+
+      duplicating_operations = input_file_contents.dup.reject { |element| !element.include?(".dup") }
+
+      duplicating_operation_indexes = []
+
+      duplicating_operations.each do |line|
+
+        duplicating_operation_indexes << input_file_contents.dup.each_index.select { |index| input_file_contents[index] == line }
+
+      end
+
+      duplicating_operation_indexes = duplicating_operation_indexes.flatten
+
+      duplicating_operation_indexes.each do |index|
+
+        input_file_contents[index] = input_file_contents[index].sub(".dup", ".slice(0)")
+
+      end
+
+      return input_file_contents
+
+    end
+
+    def compile_multiline(input_file_contents, temporary_nila_file)
+
+      possible_arrays = input_file_contents.reject { |element| !element.include?("[") }
+
+      possible_multiline_arrays = possible_arrays.reject { |element| element.include?("]") }
+
+      multiline_arrays = []
+
+      possible_multiline_arrays.each do |starting_line|
+
+        index = input_file_contents.index(starting_line)
+
+        line = starting_line
+
+        until line.include?("]")
+
+          index += 1
+
+          line = input_file_contents[index]
+
+        end
+
+        multiline_arrays << input_file_contents[input_file_contents.index(starting_line)..index]
+
+      end
+
+      joined_file_contents = input_file_contents.join
+
+      multiline_arrays.each do |array|
+
+        modified_array = array.join
+
+        array_extract = modified_array[modified_array.index("[")..modified_array.index("]")]
+
+        array_contents = array_extract.split("[")[1].split("]")[0].lstrip.rstrip.split(",").collect { |element| element.lstrip.rstrip }
+
+        array_contents = "[" + array_contents.join(",") + "]"
+
+        joined_file_contents = joined_file_contents.sub(array_extract, array_contents)
+
+      end
+
+      file_id = open(temporary_nila_file, 'w')
+
+      file_id.write(joined_file_contents)
+
+      file_id.close()
+
+      line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+
+      return line_by_line_contents
+
+    end
+
+    def compile_array_operators(input_file_contents)
+
+      possible_operator_usage = input_file_contents.reject { |element| !element.include?("<<") }
+
+      possible_operator_usage.each do |usage|
+
+        left, right = usage.split("<<")
+
+        input_file_contents[input_file_contents.index(usage)] = left.rstrip + ".push(#{right.strip})\n\n"
+
+      end
+
+      return input_file_contents
+
+    end
+
+    input_file_contents = compile_w_arrays(input_file_contents)
+
+    input_file_contents = compile_array_indexing(input_file_contents)
+
+    input_file_contents = compile_multiline(input_file_contents, temporary_nila_file)
+
+    input_file_contents = compile_array_operators(input_file_contents)
+
+    named_functions = named_functions.collect {|func| compile_w_arrays(func)}
+
+    named_functions = named_functions.collect { |func| compile_array_indexing(func)}
+
+    named_functions = named_functions.collect {|func| compile_multiline(func, temporary_nila_file)}
+
+    named_functions = named_functions.collect {|func| compile_array_operators(func)}
+
+    return input_file_contents, named_functions
+
+
+  end

data/lib/nilac/compile_blocks.rb

@@ -0,0 +1,137 @@
+require_relative 'read_file_line_by_line'
+  
+  def compile_blocks(input_file_contents,temporary_nila_file)
+
+    def compile_one_line_blocks(input_block)
+
+      block_parameters, block_contents = input_block[1...-1].split("|",2)[1].split("|",2)
+
+      compiled_block = "function(#{block_parameters.lstrip.rstrip}) {\n\n  #{block_contents.strip} \n\n}"
+
+      return compiled_block
+
+    end
+
+    input_file_contents = input_file_contents.collect {|element| element.gsub("append","appand")}
+
+    possible_blocks = input_file_contents.reject {|line| !line.include?(" do ")}
+
+    unless possible_blocks.empty?
+
+      possible_blocks.each do |starting_line|
+
+        index_counter = starting_counter = input_file_contents.index(starting_line)
+
+        line = starting_line
+
+        until line.strip.eql?("end") or line.strip.eql?("end)")
+
+          index_counter += 1
+
+          line = input_file_contents[index_counter]
+
+        end
+
+        loop_extract = input_file_contents[starting_counter..index_counter]
+
+        loop_condition, block = loop_extract.join.split(" do ")
+
+        block = block.split("end")[0]
+
+        replacement_string = "#{loop_condition.rstrip} blockky {#{block.strip}}_!"
+
+        input_file_contents[starting_counter..index_counter] = replacement_string
+
+      end
+
+    end
+
+    possible_blocks = input_file_contents.reject{ |element| !element.include?(" blockky ")}
+
+    possible_blocks = possible_blocks.reject {|element| !element.include?("{") and !element.include?("}")}
+
+    modified_file_contents = input_file_contents.clone
+
+    unless possible_blocks.empty?
+
+      possible_blocks.each do |loop|
+
+        original_loop = loop.clone
+
+        string_counter = 1
+
+        extracted_string = []
+
+        while loop.include?("\"")
+
+          string_extract = loop[loop.index("\"")..loop.index("\"",loop.index("\"")+1)]
+
+          extracted_string << string_extract
+
+          loop = loop.sub(string_extract,"--repstring#{string_counter}")
+
+          string_counter += 1
+
+        end
+
+        block_extract = loop[loop.index("{")..loop.index("}_!")]
+
+        compiled_block = ""
+
+        if block_extract.count("|") == 2
+
+          compiled_block = compile_one_line_blocks(block_extract)
+
+          extracted_string.each_with_index do |string,index|
+
+            compiled_block = compiled_block.sub("--repstring#{index+1}",string)
+
+          end
+
+        else
+
+          compiled_block = block_extract[1...-1].lstrip.rstrip
+
+          extracted_string.each_with_index do |string,index|
+
+            compiled_block = compiled_block.sub("--repstring#{index+1}",string)
+
+          end
+
+        end
+
+        caller_func = loop.split(" blockky ")[0]
+
+        unless caller_func.rstrip[-1] == ","
+
+          replacement_string = "#{caller_func.rstrip}(#{compiled_block.lstrip})"
+
+        else
+
+          caller_func_split = caller_func.split("(") if caller_func.include?("(")
+
+          caller_func_split = caller_func.split(" ",2) if caller_func.include?(" ")
+
+          replacement_string = "#{caller_func_split[0]}(#{caller_func_split[1].strip + compiled_block.lstrip})"
+
+        end
+
+        modified_file_contents[input_file_contents.index(original_loop)] = replacement_string
+
+      end
+
+    end
+
+    modified_file_contents = modified_file_contents.collect {|element| element.gsub("appand","append")}
+
+    file_id = open(temporary_nila_file, 'w')
+
+    file_id.write(modified_file_contents.join)
+
+    file_id.close()
+
+    line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+
+    return line_by_line_contents
+
+  end