rubex 0.0.1 → 0.1

data/spec/comments_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Rubex do
+  test_case = "comments"
+
+	context "Case: #{test_case}" do
+    before do
+      @path = path_str test_case
+    end
+
+    context ".ast" do
+      it "generate the AST." do
+        t = Rubex::Compiler.ast(@path + '.rubex')
+      end
+    end
+
+    context ".compile" do
+      it "compiles to C." do
+        t, c, e = Rubex::Compiler.compile(@path + '.rubex', test: true)
+      end
+    end
+
+    context "Black Box testing" do
+      it "compiles and checks for valid output" do
+        setup_and_teardown_compiled_files(test_case) do |dir|
+          require_relative "#{dir}/#{test_case}.so"
+
+          expect(crazy_comment).to eq(4)
+        end
+      end
+    end
+  end
+end

data/spec/default_args_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Rubex do
+  pending("implement default args") do
+    test_case = "default_args"
+
+    context "Case: #{test_case}" do
+      before do
+        @path = path_str test_case
+      end
+
+      context ".ast" do
+        it "generates a valid AST" do
+          t = Rubex::Compiler.ast(@path + '.rubex')
+        end
+      end
+
+      context ".compile", focus: true do
+        it "compiles to valid C code" do
+          t,c,e = Rubex::Compiler.compile(@path + '.rubex', test: true)
+        end
+      end
+
+      context "Black Box testing", focus: true do
+        it "compiles and checks for valid output" do
+          setup_and_teardown_compiled_files(test_case) do |dir|
+            require_relative "#{dir}/#{test_case}.so"
+            o = { a: "world!!" }
+            expect(default_method(1)).to eq(nil)
+            expect(default_method(1, true, o)).to eq(7)
+            expect(default_method(1, nil, {a: 44})).to eq(5)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/error_handling_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Rubex do
+  test_case = "error_handling"
+
+  context "Case: #{test_case}" do
+    before do
+      @path = path_str test_case
+    end
+
+    context ".ast" do
+      it "generates the AST" do
+        t = Rubex::Compiler.ast(@path + '.rubex')
+      end
+    end
+
+    context ".compile", focus: true do
+      it "compiles to valid C file" do
+        t,c,e = Rubex::Compiler.compile(@path + '.rubex', test: true)
+      end
+    end
+
+    context "Black box testing", focus: true do
+      it "compiles and checks for valid output" do
+        setup_and_teardown_compiled_files(test_case) do |dir|
+          require_relative "#{dir}/#{test_case}.so"
+
+          cls = Handler.new
+
+          expect(cls.error_test(1)).to eq(6)
+          expect(cls.error_test(2)).to eq(7)
+          expect(cls.error_test(3)).to eq(8)
+          expect(cls.error_test(4)).to eq(9)
+
+          expect {cls.test_uncaught_error}.to raise_error(ArgumentError)
+          expect(cls.test_without_rescue).to eq(1)
+          expect(cls.test_decl_inside_begin).to eq(44)
+        end
+      end
+    end
+  end
+end

data/spec/examples_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Rubex do
+  test_case = 'examples'
+
+  examples = ['rcsv', 'array_to_hash'].each do |example|
+    context "Case: #{test_case}/#{example}" do
+      before do
+        @path = path_str test_case, example
+      end
+
+      context ".ast" do
+        it "generates the AST" do
+          t = Rubex::Compiler.ast(@path + '.rubex')
+        end
+      end
+
+      context ".compile", now: true do
+        it "compiles to valid C file" do
+          t,c,e = Rubex::Compiler.compile(@path + '.rubex', test: true)
+        end
+      end
+
+      context "Black Box testing", now: true do
+        it "compiles and checks for valid output" do
+          def rcsv
+            result = [
+              ["Name", "age", "sex"],
+              ["Sameer", "24", "M"],
+              ["Ameya", "23", "M"],
+              ["Neeraja", "23", "F"],
+              ["Shounak", "24", "M"]
+            ]
+
+            a = Rcsv.parse(File.read('spec/fixtures/examples/rcsv.csv'), {})
+            expect(a).to eq(result)
+          end
+
+          def array_to_hash
+            a = ["a", "b", "c"]
+            expect(a.each_with_index.to_h).to eq(Array2Hash.convert(a))
+          end
+
+          setup_and_teardown_compiled_files(test_case, example) do |dir|
+            require_relative "#{dir}/#{example}.so"
+            self.send(example.to_sym)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/expressions_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Rubex do
+  test_case = "expressions"
+
+  context "Case: #{test_case}" do
+    before do
+      @path = path_str test_case
+    end
+
+    context ".ast" do
+      it "generates the AST" do
+        t = Rubex::Compiler.ast(@path + '.rubex')
+      end
+    end
+
+    context ".compile" do
+      it "compiles to valid C file" do
+        t,c,e = Rubex::Compiler.compile(@path + '.rubex', test: true)
+      end
+    end
+
+    context "Black Box testing" do
+      it "compiles and checks for valid output" do
+        setup_and_teardown_compiled_files(test_case) do |dir|
+          require_relative "#{dir}/#{test_case}.so"
+
+          expect(adder(1,3.4)).to eq(-548)
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/basic_ruby_method/basic_ruby_method.rubex

@@ -1,3 +1,5 @@
 def addition (i32 a, i32 b)
+  t = "aaa"
+  t.nil?
   return a + b
 end

data/spec/fixtures/binding_ptr_args/binding_ptr_args.rubex

@@ -0,0 +1,30 @@
+lib "<ruby/encoding.h>"
+  struct rb_encoding
+
+  end
+
+  alias rb_encoding = struct rb_encoding
+  
+  rb_encoding *rb_enc_from_index(int)
+  unsigned int rb_enc_codepoint(char *, char *, rb_encoding *)
+  int ENCODING_GET(object)
+end
+
+lib "<ruby.h>"
+  char* RSTRING_PTR(object)
+  char* RSTRING_END(object)
+end
+
+def test_function(string)
+  rb_encoding *enc
+  unsigned int cc
+  char* s
+  char* e
+
+  s = RSTRING_PTR(string)
+  e = RSTRING_END(string)
+  enc = rb_enc_from_index(ENCODING_GET(string))
+  cc = rb_enc_codepoint(s, e, enc)
+
+  return cc
+end

data/spec/fixtures/bitwise_operators/bitwise_operators.rubex

@@ -0,0 +1,40 @@
+class BitWise
+  def wise_or
+    int a = 1
+    int b = 3
+
+    return a | b
+  end
+
+  def wise_and
+    int a = 1
+    char b = 5
+
+    return a & b
+  end
+
+  def wise_xor
+    int a = 4
+    int b = 4
+
+    return a ^ b
+  end
+
+  def wise_compli
+    int a = 4
+
+    return ~a
+  end
+
+  def wise_lshift
+    int a = 3
+
+    return a << 1
+  end
+
+  def wise_rshift
+    int a = 4
+
+    return a >> 1
+  end
+end

data/spec/fixtures/blocks/blocks.rubex

@@ -0,0 +1,11 @@
+def block_scene
+  int i[6] = [1,2,3,4,5,6]
+  int j = 0
+
+  if block_given?
+    while j < 6 do
+      yield(i[j])
+      j += 1
+    end
+  end
+end

data/spec/fixtures/c_bindings/c_bindings.rubex

@@ -0,0 +1,58 @@
+lib "<math.h>"
+  double cos(double a)
+
+  struct exception
+    int type
+    char *name
+  end
+
+  double pow(double, double)
+
+  alias exec = struct exception
+end
+            
+lib "<math.h>"
+  double sin(double)        
+end
+
+class RMath
+  def ruby_sin(double x)
+    return sin(x)
+  end
+end
+
+def maths(double a, double b, c)
+  alias int_64 = i64
+  int_64 p = cos(a)
+  int_64 rr
+
+  rr = 332
+
+  exec e
+  e.type = 3
+
+  struct new_struct
+    double a,b,c
+    char* string
+  end
+
+  new_struct s
+  s.a = a
+  s.b = b
+
+  if (s.a > s.b)
+    s.string = c
+  end
+
+  return pow(6.7, s.a)
+end
+
+def stray_cos
+  return cos(4.5)
+end
+
+class A
+  def ruby_cos
+    return cos(4.5)
+  end
+end

data/spec/fixtures/c_constants/c_constants.rubex

@@ -0,0 +1,7 @@
+lib "<ruby.h>"
+  int HAVE_RUBY_DEFINES_H
+end
+
+def have_ruby_h
+  return HAVE_RUBY_DEFINES_H
+end

data/spec/fixtures/c_function_ptrs/c_function_ptrs.rubex

@@ -0,0 +1,52 @@
+cfunc int foo1(int a)
+  return a + 1
+end
+
+cfunc int foo2(int a)
+  return a + 2
+end
+
+cfunc int baz1(int a, int b)
+  return a + b + 1
+end
+
+cfunc int baz2(int a, int b)
+  return a + b + 2
+end
+
+cfunc int bar(int (*func1)(int), int (*func2)(int, int), int a, int b)
+  int ans1
+  int ans2
+
+  ans1 = func1(a)
+  ans2 = func2(a, b)
+
+  return ans1 + ans2
+end
+
+class CFunctionPtrs
+  def test_c_function_pointers(switch)
+    alias goswim = int (*ernub)(int, int)
+    int (*func_ptr1)(int)
+    goswim func_ptr2
+    int a = 1
+    int b = 1
+
+    if switch
+      func_ptr1 = foo1
+      func_ptr2 = baz1
+    else
+      func_ptr1 = foo2
+      func_ptr2 = baz2
+    end
+
+    return bar(func_ptr1, func_ptr2, a, b)
+  end
+
+  def test_pass_by_name
+    int a = 5
+    int b = 5
+
+    return bar(&foo1, &baz1, a, b)
+  end
+end

data/spec/fixtures/c_functions/c_functions.rubex

@@ -0,0 +1,25 @@
+cfunc object this_is_it
+  return "this is it."
+end
+
+class CFunctions
+  def pure_ruby_method
+    int a = 55
+    float b = 5.43
+    int c = first_c_function(a, b)
+    d = this_is_it
+
+    return a + c
+  end
+
+  cfunc int first_c_function(int a, float b)
+    int c = a + 5
+    int d = (c * b + 3)/5
+
+    return c - d
+  end
+
+  cfunc int empty
+    
+  end
+end

data/spec/fixtures/c_struct_interface/c_struct_interface.rubex

@@ -0,0 +1,34 @@
+lib "rubex/ruby"; end
+
+struct mp3info
+  char *artist, *title
+  int id
+end
+
+class Music attach mp3info
+  def initialize(artist, title, id)
+    mp3info* mp3 = data$.mp3info
+    int a_size = artist.size
+    int t_size = title.size
+
+    mp3.artist = artist # implicit conversion of Ruby String to char*
+    mp3.title = title # implicit conversion of Ruby String to char*
+    mp3.id = id # implicit typecast to int
+  end
+
+  cfunc void deallocate
+    xfree(data$.mp3info)
+  end
+
+  def artist
+    return data$.mp3info.artist # typecast to ruby string
+  end
+
+  def title
+    return data$.mp3info.title # typecast to ruby string
+  end
+
+  def id
+    return data$.mp3info.id
+  end
+end