nilac 0.0.4.2.0 → 0.0.4.2.1

data/lib/nilac/version.rb

@@ -1,3 +1,3 @@
 module Nilac
-  VERSION = "0.0.4.2.0"
+  VERSION = "0.0.4.2.1"
 end

data/shark/features/hashes.feature

@@ -0,0 +1,11 @@
+Feature: This feature brings Ruby style Hashes to Nila
+  Scenario: Input file with hashes. 
+    Given the input file "hashes.nila"
+    When the ~compiler is run
+    The output file must be "hashes.js"
+    The output file must equal "correct_hashes.js"
+
+Configurations:
+
+~compiler => src/nilac.rb
+:v $cliusage => ruby :v --compile $file

data/shark/features/loop.feature

@@ -0,0 +1,11 @@
+Feature: This feature brings loop keyword to Nila
+  Scenario: Input file with loop keyword. 
+    Given the input file "loop.nila"
+    When the ~compiler is run
+    The output file must be "loop.js"
+    The output file must equal "correct_loop.js"
+
+Configurations:
+
+~compiler => src/nilac.rb
+:v $cliusage => ruby :v --compile $file

data/shark/test_files/correct_hashes.js

@@ -0,0 +1,31 @@
+//Written using Nila. Visit http://adhithyan15.github.io/nila
+(function() {
+  var inst_section, student_ages;
+
+  // This file demonstrates several Hash features in Nila
+
+  inst_section = {
+    cello: 'string',
+    clarinet: 'woodwind',
+    drum: 'percussion',
+    oboe: 'woodwind',
+    trumpet: 'brass',
+    violin: 'string',
+    guitar: 'string',
+  };
+
+  if (variable === 10) {
+    process.stdout.write("Variable is 10");
+  } else if (variable === 20) {
+    process.stdout.write("Variable is 20");
+  } else {
+    process.stdout.write("Variable is something else")
+  }
+
+  student_ages = {
+    Jack: 10,
+    Jill: 12,
+    Bob: 14,
+  };
+
+}).call(this);

data/shark/test_files/correct_loop.js

@@ -0,0 +1,15 @@
+//Written using Nila. Visit http://adhithyan15.github.io/nila
+(function() {
+  var i;
+
+  i=0;
+
+  while (true) {
+    i+=1;
+    process.stdout.write("" + i + " ");
+    if (i===10) {
+      break;
+    }
+  }
+
+}).call(this);

data/shark/test_files/correct_operators.js

@@ -1,6 +1,6 @@
 //Written using Nila. Visit http://adhithyan15.github.io/nila
 (function() {
-  var a;
+  var a, line;
 
   a = Math.pow(2,3);
 
@@ -8,4 +8,10 @@
     console.log("Correct Calculation!");
   }
 
+  line = "My favorite language is Ruby!";
+
+  if (line = line.match(/Ruby|Python/)) {
+    console.log("Scripting language mentioned: " + line);
+  }
+
 }).call(this);

data/shark/test_files/correct_unless_until.js

@@ -2,9 +2,9 @@
 (function() {
   var i;
 
-  // This file demonstrates unless && until statements.
+  // This file demonstrates unless and until statements.
 
-  // Examples are from http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators/ && 
+  // Examples are from http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators/ and 
 
   // http://37signals.com/svn/posts/2699-making-sense-with-rubys-unless 
 

data/shark/test_files/hashes.nila

@@ -0,0 +1,21 @@
+# This file demonstrates several Hash features in Nila
+
+inst_section = {
+  'cello' => 'string',
+  'clarinet' => 'woodwind',
+  'drum': 'percussion',
+  'oboe' : 'woodwind',
+  'trumpet' => 'brass',
+  'violin' => 'string',
+  :guitar => 'string'
+}
+
+if variable == 10
+   print "Variable is 10"
+elsif variable == 20
+   print "Variable is 20"
+else
+   print "Variable is something else"
+end
+
+student_ages = {"Jack" => 10,"Jill" => 12,"Bob" => 14}

data/shark/test_files/loop.nila

@@ -0,0 +1,6 @@
+i=0
+loop do
+  i+=1
+  print "#{i} "
+  break if i==10
+end

data/shark/test_files/operators.nila

@@ -1,3 +1,9 @@
 a = 2**3
 
-puts "Correct Calculation!" if a == 8
+puts "Correct Calculation!" if a == 8
+
+line = "My favorite language is Ruby!"
+
+if line =~ /Ruby|Python/
+	puts "Scripting language mentioned: #{line}"
+end

data/src/nilac.rb

@@ -750,6 +750,8 @@ def compile(input_file_path, *output_file_name)
 
     input_file_contents = input_file_contents.collect { |element| element.gsub("%=", "modequal") }
 
+    input_file_contents = input_file_contents.collect { |element| element.gsub("=~", "matchequal") }
+
     for x in 0...input_file_contents.length
 
       current_row = input_file_contents[x]
@@ -814,6 +816,8 @@ def compile(input_file_path, *output_file_name)
 
     line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("notequal", "!=") }
 
+    line_by_line_contents = line_by_line_contents.collect { |element| element.gsub("matchequal", "=~") }
+
     return variables.uniq, line_by_line_contents
 
   end
@@ -1136,6 +1140,108 @@ def compile(input_file_path, *output_file_name)
 
   end
 
+  def compile_hashes(input_file_contents,temporary_nila_file)
+
+    def compile_multiline_hashes(input_file_contents,temporary_nila_file)
+
+      possible_hashes = input_file_contents.reject { |element| !element.include?("{") }
+
+      possible_multiline_hashes = possible_hashes.reject { |element| element.include?("}") }
+
+      multiline_hashes = []
+
+      possible_multiline_hashes.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_hashes << input_file_contents[input_file_contents.index(starting_line)..index]
+
+      end
+
+      joined_file_contents = input_file_contents.join
+
+      multiline_hashes.each do |hash|
+
+        modified_hash = hash.join
+
+        hash_extract = modified_hash[modified_hash.index("{")..modified_hash.index("}")]
+
+        hash_contents = hash_extract.split("{")[1].split("}")[0].lstrip.rstrip.split(",").collect { |element| element.lstrip.rstrip }
+
+        hash_contents = "{" + hash_contents.join(",") + "}"
+
+        joined_file_contents = joined_file_contents.sub(hash_extract, hash_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_inline_hashes(input_file_contents)
+
+      modified_file_contents = input_file_contents.clone.collect {|element| element.gsub(/(#|%)\w?\{/,"innerrii0opol115")}
+
+      possible_inline_hashes = modified_file_contents.reject {|element| !element.include?("{")}
+
+      possible_inline_hashes.each do |hash|
+
+        hash_extract = hash[hash.index("{")..hash.index("}")]
+
+        contents = hash_extract[1...-1].split(",")
+
+        hash_contents = []
+
+        contents.each do |items|
+
+          items = items.lstrip.sub(":","") if items.lstrip[0] == ":"
+
+          key, value = items.split("=>").collect {|element| element.lstrip.rstrip} if items.include?("=>")
+
+          key, value = items.split(":").collect {|element| element.lstrip.rstrip} if items.include?(":")
+
+          key = key.gsub("'","").gsub("\"","")
+
+          hash_contents << "  #{key}: #{value},"
+
+        end
+
+        replacement_string = "{\n" + hash_contents.join("\n") + "\n};\n"
+
+        input_file_contents[input_file_contents.index(hash)] = input_file_contents[input_file_contents.index(hash)].sub(hash_extract,replacement_string)
+
+      end
+
+      return input_file_contents
+
+    end
+
+    file_contents = compile_multiline_hashes(input_file_contents,temporary_nila_file)
+
+    file_contents = compile_inline_hashes(file_contents)
+
+    return file_contents
+
+  end
+
   def compile_strings(input_file_contents)
 
     def compile_small_q_syntax(input_file_contents)
@@ -1837,6 +1943,8 @@ def compile(input_file_path, *output_file_name)
 
         junk, condition = command.split("unless ")
 
+        condition = condition.gsub(" and "," && ").gsub(" or "," || ").gsub(" not "," !")
+
         replacement_string = "if !(#{condition.lstrip.rstrip})\n"
 
         modified_file_contents[modified_file_contents.index(command)] = replacement_string
@@ -1851,6 +1959,8 @@ def compile(input_file_path, *output_file_name)
 
         junk, condition = command.split("until ")
 
+        condition = condition.gsub(" and "," && ").gsub(" or "," || ").gsub(" not "," !")
+
         replacement_string = "while !(#{condition.lstrip.rstrip})\n"
 
         modified_file_contents[modified_file_contents.index(command)] = replacement_string
@@ -1879,21 +1989,25 @@ def compile(input_file_path, *output_file_name)
 
           line_split = line.split(plain_conditionals[index])
 
+          condition = line_split[1]
+
+          condition = condition.gsub(" and "," && ").gsub(" or "," || ").gsub(" not "," !")
+
           if index == 0
 
-            output_statement = "if (#{line_split[1].lstrip.rstrip.gsub("?", "")}) {\n\n#{line_split[0]}\n}\n"
+            output_statement = "if (#{condition.lstrip.rstrip.gsub("?", "")}) {\n\n#{line_split[0]}\n}\n"
 
           elsif index == 1
 
-            output_statement = "while (#{line_split[1].lstrip.rstrip.gsub("?", "")}) {\n\n#{line_split[0]}\n}\n"
+            output_statement = "while (#{condition.lstrip.rstrip.gsub("?", "")}) {\n\n#{line_split[0]}\n}\n"
 
           elsif index == 2
 
-            output_statement = "if (!(#{line_split[1].lstrip.rstrip.gsub("?", "")})) {\n\n#{line_split[0]}\n}\n"
+            output_statement = "if (!(#{condition.lstrip.rstrip.gsub("?", "")})) {\n\n#{line_split[0]}\n}\n"
 
           elsif index == 3
 
-            output_statement = "while (!(#{line_split[1].lstrip.rstrip.gsub("?", "")})) {\n\n#{line_split[0]}\n}\n"
+            output_statement = "while (!(#{condition.lstrip.rstrip.gsub("?", "")})) {\n\n#{line_split[0]}\n}\n"
 
           end
 
@@ -2059,6 +2173,8 @@ def compile(input_file_path, *output_file_name)
 
         junk, condition = starting_line.split("if")
 
+        condition = condition.gsub(" and "," && ").gsub(" or "," || ").gsub(" not "," !")
+
         input_block[0] = "Euuf (#{condition.lstrip.rstrip.gsub("?", "")}) {\n"
 
         input_block[-1] = input_block[-1].lstrip.sub("end", "}")
@@ -2069,6 +2185,8 @@ def compile(input_file_path, *output_file_name)
 
           junk, condition = statement.split("elsuf")
 
+          condition = condition.gsub(" and "," && ").gsub(" or "," || ").gsub(" not "," !")
+
           input_block[input_block.index(statement)] = "} elsuf (#{condition.lstrip.rstrip.gsub("?", "")}) {\n"
 
         end
@@ -2479,6 +2597,274 @@ def compile(input_file_path, *output_file_name)
 
     end
 
+    def compile_loop_keyword(input_file_contents,temporary_nila_file)
+
+      def convert_string_to_array(input_string, temporary_nila_file)
+
+        file_id = open(temporary_nila_file, 'w')
+
+        file_id.write(input_string)
+
+        file_id.close()
+
+        line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+
+        return line_by_line_contents
+
+      end
+
+      def extract_loop_blocks(loop_statement_indexes, input_file_contents)
+
+        possible_loop_blocks = []
+
+        loop_block_counter = 0
+
+        extracted_blocks = []
+
+        controlregexp = /(if |while |def |loop )/
+
+        rejectionregexp = /( if | while )/
+
+        for x in 0...loop_statement_indexes.length-1
+
+          possible_loop_blocks << input_file_contents[loop_statement_indexes[x]..loop_statement_indexes[x+1]]
+
+        end
+
+        end_counter = 0
+
+        end_index = []
+
+        current_block = []
+
+        possible_loop_blocks.each_with_index do |block|
+
+          current_block += block
+
+          current_block.each_with_index do |line, index|
+
+            if line.strip.eql? "end"
+
+              end_counter += 1
+
+              end_index << index
+
+            end
+
+          end
+
+          if end_counter > 0
+
+            until end_index.empty?
+
+              array_extract = current_block[0..end_index[0]].reverse
+
+              index_counter = 0
+
+              array_extract.each_with_index do |line|
+
+                break if (line.lstrip.index(controlregexp) != nil and line.lstrip.index(rejectionregexp).nil?)
+
+                index_counter += 1
+
+              end
+
+              block_extract = array_extract[0..index_counter].reverse
+
+              extracted_blocks << block_extract
+
+              block_start = current_block.index(block_extract[0])
+
+              block_end = current_block.index(block_extract[-1])
+
+              current_block[block_start..block_end] = "--loopblock#{loop_block_counter}"
+
+              loop_block_counter += 1
+
+              end_counter = 0
+
+              end_index = []
+
+              current_block.each_with_index do |line, index|
+
+                if line.strip.eql? "end"
+
+                  end_counter += 1
+
+                  end_index << index
+
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+        return current_block, extracted_blocks
+
+      end
+
+      def compile_loop_syntax(input_block)
+
+        modified_input_block = input_block.dup
+
+        strings = []
+
+        string_counter = 0
+
+        input_block.each_with_index do |line, index|
+
+          if line.include?("\"")
+
+            opening_quotes = line.index("\"")
+
+            string_extract = line[opening_quotes..line.index("\"", opening_quotes+1)]
+
+            strings << string_extract
+
+            modified_input_block[index] = modified_input_block[index].sub(string_extract, "--string{#{string_counter}}")
+
+            string_counter += 1
+
+          end
+
+        end
+
+        input_block = modified_input_block
+
+        starting_line = input_block[0]
+
+        starting_line = starting_line + "\n" if starting_line.lstrip == starting_line
+
+        input_block[0] = "whaaleskey (true) {\n"
+
+        input_block[-1] = input_block[-1].lstrip.sub("end", "}")
+
+        modified_input_block = input_block.dup
+
+        input_block.each_with_index do |line, index|
+
+          if line.include?("--string{")
+
+            junk, remains = line.split("--string{")
+
+            string_index, junk = remains.split("}")
+
+            modified_input_block[index] = modified_input_block[index].sub("--string{#{string_index.strip}}", strings[string_index.strip.to_i])
+
+          end
+
+        end
+
+        return modified_input_block
+
+      end
+
+      possible_loop_statements = input_file_contents.reject { |element| !element.include?("loop") }
+
+      if !possible_loop_statements.empty?
+
+        loop_statement_indexes = []
+
+        possible_loop_statements.each do |statement|
+
+          loop_statement_indexes << input_file_contents.dup.each_index.select { |index| input_file_contents[index] == statement }
+
+        end
+
+        loop_statement_indexes = [0] + loop_statement_indexes.flatten + [-1]
+
+        controlregexp = /(if |def )/
+
+        modified_input_contents, extracted_statements = extract_loop_blocks(loop_statement_indexes, input_file_contents.clone)
+
+        joined_blocks = extracted_statements.collect { |element| element.join }
+
+        loop_statements = joined_blocks.reject { |element| element.index(controlregexp) != nil }
+
+        rejected_elements = joined_blocks - loop_statements
+
+        rejected_elements_index = []
+
+        rejected_elements.each do |element|
+
+          rejected_elements_index << joined_blocks.each_index.select { |index| joined_blocks[index] == element }
+
+        end
+
+        loop_blocks_index = (0...extracted_statements.length).to_a
+
+        rejected_elements_index = rejected_elements_index.flatten
+
+        loop_blocks_index -= rejected_elements_index
+
+        modified_loop_statements = loop_statements.collect { |string| convert_string_to_array(string, temporary_nila_file) }
+
+        modified_loop_statements = modified_loop_statements.collect { |block| compile_loop_syntax(block) }.reverse
+
+        loop_blocks_index = loop_blocks_index.collect { |element| "--loopblock#{element}" }.reverse
+
+        rejected_elements_index = rejected_elements_index.collect { |element| "--loopblock#{element}" }.reverse
+
+        rejected_elements = rejected_elements.reverse
+
+        joined_file_contents = modified_input_contents.join
+
+        until loop_blocks_index.empty? and rejected_elements_index.empty?
+
+          if !loop_blocks_index.empty?
+
+            if joined_file_contents.include?(loop_blocks_index[0])
+
+              joined_file_contents = joined_file_contents.sub(loop_blocks_index[0], modified_loop_statements[0].join)
+
+              loop_blocks_index.delete_at(0)
+
+              modified_loop_statements.delete_at(0)
+
+            else
+
+              joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0].join)
+
+              rejected_elements_index.delete_at(0)
+
+              rejected_elements.delete_at(0)
+
+            end
+
+          else
+
+            joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0].join)
+
+            rejected_elements_index.delete_at(0)
+
+            rejected_elements.delete_at(0)
+
+          end
+
+        end
+
+      else
+
+        joined_file_contents = input_file_contents.join
+
+      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 ignore_statement_modifiers(input_block)
 
       modified_input_block = input_block.dup
@@ -2555,6 +2941,8 @@ def compile(input_file_path, *output_file_name)
 
     file_contents = compile_regular_while(file_contents, temporary_nila_file)
 
+    file_contents = compile_loop_keyword(file_contents,temporary_nila_file)
+
     file_contents = replace_statement_modifiers(file_contents, rejected_lines)
 
     file_contents = compile_inline_conditionals(file_contents, temporary_nila_file)
@@ -2585,9 +2973,9 @@ def compile(input_file_path, *output_file_name)
 
     reject_regexp = /(function |Euuf |if |else|elsuf|switch |case|while |whaaleskey |for )/
 
-    modified_file_contents = []
+    modified_file_contents = input_file_contents.dup
 
-    input_file_contents.each do |line|
+    input_file_contents.each_with_index do |line,index|
 
       if line.index(reject_regexp) == nil
 
@@ -2599,36 +2987,20 @@ def compile(input_file_path, *output_file_name)
 
               if !line.lstrip.eql?("}\n\n")
 
-                modified_file_contents << line.rstrip + ";\n\n"
+                if line.rstrip[-1] != "[" and line.rstrip[-1] != "{" and line.rstrip[-1] != "," and line.rstrip[-1] != ";"
 
-              else
+                  modified_file_contents[index] = line.rstrip + ";\n\n"
 
-                modified_file_contents << line
+                end
 
               end
 
-            else
-
-              modified_file_contents << line
-
             end
 
-          else
-
-            modified_file_contents << line
-
           end
 
-        else
-
-          modified_file_contents << line
-
         end
 
-      else
-
-        modified_file_contents << line
-
       end
 
     end
@@ -2779,7 +3151,7 @@ def compile(input_file_path, *output_file_name)
 
       def extract_blocks(file_contents)
 
-        javascript_regexp = /(if |while |function |function\()/
+        javascript_regexp = /(if |while |function |function\(|((=|:)\s+\{))/
 
         block_starting_lines = file_contents.dup.reject { |element| element.index(javascript_regexp).nil? }[1..-1]
 
@@ -2795,7 +3167,7 @@ def compile(input_file_path, *output_file_name)
 
         end
 
-        block_ending_lines = file_contents.dup.each_index.select { |index| file_contents[index].eql? "  }\n" }
+        block_ending_lines = file_contents.dup.each_index.select { |index| (file_contents[index].eql? "  }\n" or file_contents[index].eql? "  };\n")}
 
         modified_file_contents = file_contents.dup
 
@@ -2825,7 +3197,7 @@ def compile(input_file_path, *output_file_name)
 
             end
 
-            block_ending_lines = modified_file_contents.dup.each_index.select { |index| modified_file_contents[index].eql? "  }\n" }
+            block_ending_lines = modified_file_contents.dup.each_index.select { |index| (modified_file_contents[index].eql? "  }\n" or modified_file_contents[index].eql? "  };\n") }
 
             starting_index = starting_line_indices[0]
 
@@ -2880,7 +3252,7 @@ def compile(input_file_path, *output_file_name)
 
       if !code_block_starting_locations.empty?
 
-        controlregexp = /(if |while |function |function\()/
+        controlregexp = /(if |while |function |function\(|((=|:)\s+\{))/
 
         code_block_starting_locations = [0, code_block_starting_locations, -1].flatten
 
@@ -2908,7 +3280,7 @@ def compile(input_file_path, *output_file_name)
 
           current_block.each_with_index do |line, index|
 
-            if line.lstrip.eql? "}\n"
+            if line.lstrip.eql? "}\n" or line.lstrip.eql?("};\n")
 
               end_counter += 1
 
@@ -3010,7 +3382,7 @@ def compile(input_file_path, *output_file_name)
 
     end
 
-    javascript_regexp = /(if |while |function |function\()/
+    javascript_regexp = /(if |while |function |function\(|((=|:)\s+\{))/
 
     javascript_file_contents = javascript_file_contents.collect { |element| element.sub("Euuf", "if") }
 
@@ -3176,9 +3548,49 @@ def compile(input_file_path, *output_file_name)
 
     end
 
-    input_file_contents = input_file_contents.collect { |element| element.sub(" and ", " && ") }
+    def compile_match_operator(input_string)
+
+      rejection_exp = /( aannddy | orriioo |nnoottyy )/
+
+      if input_string.include?("=~")
+
+        input_string = input_string.gsub(" && "," aannddy ").gsub(" || "," orriioo ").gsub("!","nnoottyy")
+
+        left, right = input_string.split("=~")
+
+        if left.index(rejection_exp) != nil
 
-    input_file_contents = input_file_contents.collect { |element| element.sub(" or ", " || ") }
+          left = left[left.index(rejection_exp)..-1]
+
+        elsif left.index(/\(/)
+
+          left = left[left.index(/\(/)+1..-1]
+
+        end
+
+        if right.index(rejection_exp) != nil
+
+          right = right[0...right.index(rejection_exp)]
+
+        elsif right.index(/\)/)
+
+          right = right[0...right.index(/\)/)]
+
+        end
+
+        original_string = "#{left}=~#{right}"
+
+        replacement_string = "#{left.rstrip} = #{left.rstrip}.match(#{right.lstrip.rstrip})"
+
+        input_string = input_string.sub(original_string,replacement_string)
+
+        input_string = input_string.gsub(" aannddy "," && ").gsub(" orriioo "," || ").gsub("nnoottyy","!")
+
+      end
+
+      return input_string
+
+    end
 
     input_file_contents = input_file_contents.collect { |element| element.sub("==", "===") }
 
@@ -3188,6 +3600,8 @@ def compile(input_file_path, *output_file_name)
 
     input_file_contents = input_file_contents.collect { |element| compile_power_operator(element) }
 
+    input_file_contents = input_file_contents.collect {|element| compile_match_operator(element)}
+
     return input_file_contents
 
   end
@@ -3227,6 +3641,8 @@ def compile(input_file_path, *output_file_name)
 
     file_contents = compile_interpolated_strings(file_contents)
 
+    file_contents = compile_hashes(file_contents,temp_file)
+
     file_contents = compile_conditional_structures(file_contents, temp_file)
 
     file_contents = compile_arrays(file_contents, temp_file)
@@ -3327,7 +3743,7 @@ def find_file_path(input_path, file_extension)
 
 end
 
-nilac_version = "0.0.4.2.0"
+nilac_version = "0.0.4.2.1"
 
 opts = Slop.parse do
   on :c, :compile=, 'Compile Nila File', as:Array, delimiter:":"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nilac
 version: !ruby/object:Gem::Version
-  version: 0.0.4.2.0
+  version: 0.0.4.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-26 00:00:00.000000000 Z
+date: 2013-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shark
@@ -65,7 +65,9 @@ files:
 - shark/features/barebones_compilation.feature
 - shark/features/default_method_parameters.feature
 - shark/features/fix_newlines.feature
+- shark/features/hashes.feature
 - shark/features/heredoc.feature
+- shark/features/loop.feature
 - shark/features/method_multiple_return.feature
 - shark/features/multiline_array.feature
 - shark/features/multiple_variable_initialization.feature
@@ -79,9 +81,11 @@ files:
 - shark/test_files/array_string_indexing.nila
 - shark/test_files/correct.js
 - shark/test_files/correct_default_parameters.js
+- shark/test_files/correct_hashes.js
 - shark/test_files/correct_heredoc.js
 - shark/test_files/correct_indexing.js
 - shark/test_files/correct_initialization.js
+- shark/test_files/correct_loop.js
 - shark/test_files/correct_multiline_array.js
 - shark/test_files/correct_multiple_return.js
 - shark/test_files/correct_operators.js
@@ -95,7 +99,9 @@ files:
 - shark/test_files/correct_whitespace_delimiter.js
 - shark/test_files/default_parameters.nila
 - shark/test_files/erratic.nila
+- shark/test_files/hashes.nila
 - shark/test_files/heredoc.nila
+- shark/test_files/loop.nila
 - shark/test_files/multiline_array.nila
 - shark/test_files/multiple_initialization.nila
 - shark/test_files/multiple_return.nila