nilac 0.0.4.3.9.7.1 → 0.0.4.3.9.8

data/lib/nilac/compile_nilac_options.rb

@@ -0,0 +1,79 @@
+require_relative 'read_file_line_by_line'
+
+def compose_nilac_options(input_options = {})
+
+  available_options = %w{bare strict-mode client server print}
+
+  output_options = {
+
+      :bare => false,
+
+      :strict_mode => false,
+
+      :client => false,
+
+      :server => true,
+
+      :print => false
+
+  }
+
+  options = input_options.clone.reject {|key,value| value.nil?}
+
+  options.each do |key,value|
+
+    current_options = options[key]
+
+    if current_options.include?("--bare") or current_options.include?("-b")
+
+      output_options[:bare] = true
+
+      input_options[key].delete("--bare")
+
+      input_options[key].delete("-b")
+
+    end
+
+    if current_options.include?("--strict-mode")
+
+      output_options[:strict_mode] = true
+
+      input_options[key].delete("--strict-mode")
+
+    end
+
+    if current_options.include?("--client") or current_options.include?("--browser")
+
+      output_options[:client] = true
+
+      input_options[key].delete("--client")
+
+      input_options[key].delete("--browser")
+
+    end
+
+    if current_options.include?("--server") or current_options.include?("--node")
+
+      output_options[:node] = true
+
+      input_options[key].delete("--server")
+
+      input_options[key].delete("--node")
+
+    end
+
+    if current_options.include?("--print") or current_options.include?("-p")
+
+      output_options[:print] = true
+
+      input_options[key].delete("--print")
+
+      input_options[key].delete("-p")
+
+    end
+
+  end
+
+  return output_options
+
+end

data/lib/nilac/compile_parallel_assignment.rb

@@ -14,7 +14,9 @@ require_relative 'paranthesis_compactor'
 
       if input_string.include?("=") and input_string.index(javascript_regexp) == nil and input_string.strip[0..3] != "_ref" and !input_string.split("=")[1].include?("[")
 
-        right_side = input_string.split("=")[1]
+        right_side = input_string.split("=")[1] if input_string.count("=").eql?(1)
+
+        right_side = input_string.split("=",2)[1] if input_string.count("=") > 1
 
         if compact_paranthesis(right_side).include?(",")
 

data/lib/nilac/compile_ranges.rb

@@ -0,0 +1,60 @@
+def compile_ranges(input_file_contents)
+
+  # Currently, no implementation of Ranges exist for Nila. So we will be slowly developing one.
+  # In Ruby, Ranges are a separate entity and are not part of Arrays. Nila will take a similar approach to Ranges.
+
+  # In this section, we are introducing two Scala keywords to make range declaration more descriptive.
+  # The two new keywords are *to* and *until*
+
+  # Example:
+
+  # [1 to 5] is equivalent to [1..5]
+  # [1 until 5] is equivalent to [1...5]
+
+  triple_ranges = input_file_contents.reject {|element| !element.index(/(\d+\s*until\s*\d+|last)/)}
+
+  triple_ranges = triple_ranges.reject {|element| element.index(/(\d+\s*\.\.\.\s*\d+|last)/)}
+
+  triple_ranges.each do |line|
+
+    line_index = input_file_contents.index(line)
+
+    range_extracts = line.scan(/(\d+\s*until\s*\d+|last)/).to_a
+
+    range_extracts.each do |range|
+
+      begin_num,end_num = range[0].split("until").collect {|element| element.strip}
+
+      replacement_string = "#{begin_num}...#{end_num}"
+
+      input_file_contents[line_index] = input_file_contents[line_index].sub(range[0],replacement_string)
+
+    end
+
+  end
+
+  double_ranges = input_file_contents.reject {|element| !element.index(/(\d+\s*to\s*\d+|last)/)}
+
+  double_ranges = double_ranges.reject {|element| element.index(/(\d+\s*\.\.\s*\d+|last)/)}
+
+  double_ranges.each do |line|
+
+    line_index = input_file_contents.index(line)
+
+    range_extracts = line.scan(/(\d+\s*to\s*\d+|last)/).to_a
+
+    range_extracts.each do |range|
+
+      begin_num,end_num = range[0].split("to").collect {|element| element.strip}
+
+      replacement_string = "#{begin_num}..#{end_num}"
+
+      input_file_contents[line_index] = input_file_contents[line_index].sub(range[0],replacement_string)
+
+    end
+
+  end
+
+  return input_file_contents
+
+end

data/lib/nilac/compile_require_statements.rb

@@ -12,9 +12,11 @@ def compile_require_statements(input_file_contents)
  #
  # var fs = require('fs')
 
- modified_file_contents = input_file_contents.collect {|element| replace_strings(element)}
+ modified_file_contents = input_file_contents.clone
 
- possible_require_calls = modified_file_contents.reject {|element| !element.include?("require")}
+ modified_file_contents = modified_file_contents.collect {|element| element.rstrip + " "*Random.new.rand(1..20) + "\n\n"}
+
+ possible_require_calls = modified_file_contents.reject {|element| !replace_strings(element).include?("require")}
 
  possible_require_calls.each do |statement|
 

data/lib/nilac/compile_ruby_math.rb

@@ -0,0 +1,20 @@
+def compile_ruby_math(input_file_contents)
+
+  # Ruby and Javascript both has powerful features. This library will be used to compile
+  # code written using the Ruby math library into Javascript Math library code
+
+  constant_value_map = {
+
+      "Math::E" => "Math.E"
+
+  }
+
+  constant_value_map.each do |key,value|
+
+    input_file_contents = input_file_contents.collect {|element| element.gsub(key,value)}
+
+  end
+
+  return input_file_contents
+
+end

data/lib/nilac/compile_ruby_methods.rb

@@ -43,6 +43,44 @@
 
     end
 
+    def compile_simple_parameter_taking_methods(input_file_contents)
+
+      method_map_replacement = {
+
+          ".index" => ".indexOf"
+
+      }
+
+      method_map = method_map_replacement.keys
+
+      method_map_regex = method_map.collect {|name| name.gsub(".","\\.")}
+
+      method_map_regex = Regexp.new(method_map_regex.join("|"))
+
+      modified_file_contents = input_file_contents.clone
+
+      input_file_contents.each_with_index do |line, index|
+
+        if line.match(method_map_regex)
+
+          method_match = line.match(method_map_regex).to_a[0]
+
+          if line.include?(method_match + "(")
+
+            line = line.gsub(method_match,method_map_replacement[method_match])
+
+          end
+
+        end
+
+        modified_file_contents[index] = line
+
+      end
+
+      return modified_file_contents
+
+    end
+
     method_map_replacement = {
 
         ".split" => ".split(\" \")",
@@ -61,12 +99,21 @@
 
         ".empty" => ".length == 0",
 
+        ".notempty" => ".length != 0",
+
         ".upcase" => ".toUpperCase()",
 
         ".downcase" => ".toLowerCase()",
 
         ".zero?" => " === 0",
 
+        ".eql" => " === ",
+
+        ".next" => "++",
+
+        ".each" => ".forEach"
+
+
     }
 
     method_map = method_map_replacement.keys
@@ -97,6 +144,8 @@
 
     modified_file_contents = compile_complex_methods(modified_file_contents)
 
+    modified_file_contents = compile_simple_parameter_taking_methods(modified_file_contents)
+
     return modified_file_contents
 
   end

data/lib/nilac/compile_whitespace_delimited_functions.rb

@@ -63,17 +63,31 @@ require_relative 'replace_strings'
 
             matching_strings = extract(joined_file_contents, function+" ", "\n")
 
+            matching_strings = matching_strings.reject {|element| !element.index(Regexp.new(function + /\s+=/.source)).nil?}
+
             matching_strings.each do |string|
 
               modified_string = string.dup
 
+              modified_string,comment = modified_string.split("--single_line_comment")
+
+              modified_string = modified_string + "\n" if modified_string != (modified_string + "\n")
+
               modified_string = modified_string.rstrip + modified_string.split(modified_string.rstrip)[1].gsub(" ", "")
 
               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")
+              if !comment.nil? and comment.strip != ""
+
+                modified_string = modified_string.sub("\n", ") --single_line_comment#{comment}\n")
+
+              else
+
+                modified_string = modified_string.sub("\n", ")\n")
+
+              end
 
               joined_file_contents = joined_file_contents.sub(string, modified_string)
 

data/lib/nilac/extract_paranthesis_contents.rb

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

data/lib/nilac/extract_strings.rb

@@ -0,0 +1,63 @@
+# This is a simple method to extract user written strings
+
+def extract_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
+
+  string_array = []
+
+  if input_string.count("\"") % 2 == 0
+
+    while input_string.include?("\"")
+
+      string_extract = input_string[input_string.index("\"")..input_string.index("\"",input_string.index("\"")+1)]
+
+      string_array << string_extract
+
+      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_array << string_extract
+
+      string_counter += 1
+
+    end
+
+  end
+
+  return string_array
+
+end

data/lib/nilac/fix_javascript_traps.rb

@@ -0,0 +1,89 @@
+require_relative 'replace_strings'
+require_relative 'extract_paranthesis_contents'
+
+def fix_javascript_traps(input_file_contents)
+
+  # One of the design goals of Nila is to fix to Javascript traps
+
+  # parseInt is a potential trap if you forget the radix parameter. So
+  # Nila automatically includes the radix parameter of 10 if you forget to include a parameter
+  # so that you don't get weird conversions like the one mentioned in
+  # http://stackoverflow.com/questions/850341/how-do-i-work-around-javascripts-parseint-octal-behavior
+
+  def fix_parseint_default(input_file_contents)
+
+    possible_parseints = input_file_contents.reject {|element| !replace_strings(element).include?("parseInt")}
+
+    no_radix = []
+
+    no_radix_lines = []
+
+    possible_parseints.each do |str|
+
+      index = input_file_contents.index(str)
+
+      no_radix << []
+
+      no_radix_lines << []
+
+      paran_extracts = extract_paranthesis_contents(str)
+
+      paran_extracts = paran_extracts.reject {|element| element.strip.eql?("")}
+
+      paran_extracts.each do |extract|
+
+        if input_file_contents[index].include?("parseInt#{extract}")
+
+          extracted_parseint = "parseInt#{extract}"
+
+          extract_split = replace_strings(extract).split(",")
+
+          if extract_split.length == 1
+
+            no_radix[-1] << extracted_parseint
+
+            no_radix_lines[-1] << input_file_contents[index]
+
+          end
+
+        end
+
+      end
+
+    end
+
+    no_radix_lines = no_radix_lines.collect{|element| element.uniq}
+
+    no_radix_lines = no_radix_lines.reject {|element| element.empty?}
+
+    no_radix = no_radix.reject {|element| element.empty?}
+
+    no_radix_lines.each_with_index do |element,index|
+
+      extracted_parseints = no_radix[index]
+
+      modified_element = element[0].clone
+
+      extracted_parseints.each do |parseint|
+
+        replacement_string = parseint[0...-1] + ",10" + parseint[-1]
+
+        modified_element = modified_element.sub(parseint,replacement_string)
+
+      end
+
+      input_file_contents[input_file_contents.index(element[0])] = modified_element
+
+    end
+
+    return input_file_contents
+
+  end
+
+  input_file_contents = fix_parseint_default(input_file_contents)
+
+
+  return input_file_contents
+
+
+end