fastruby 0.0.19 → 0.0.20

data/lib/fastruby/translator/translator_modules.rb

@@ -41,7 +41,9 @@ module FastRuby
     end
 
     def load_under(dir)
-      each_under(dir, &method(:require))
+      each_under(dir) do |path|
+        require path
+      end
     end
   end
 end

data/lib/fastruby/translator/translator_modules.rb~

@@ -0,0 +1,53 @@
+=begin
+
+This file is part of the fastruby project, http://github.com/tario/fastruby
+
+Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+fastruby is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+fastruby is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+require "singleton"
+
+module FastRuby
+  class TranslatorModules
+    include Singleton    
+   
+    attr_accessor :modls
+    
+    def initialize
+      @modls = Array.new
+    end
+    
+    def register_translator_module(modl)
+      @modls << modl  
+    end
+    
+    def each_under(dir)
+      Dir.glob(dir + "/*.rb") do |x|
+        yield x
+      end
+    end
+
+    def load_under(dir)
+      each_under(dir, &method(:require))
+    end
+  end
+end
+
+module Kernel
+    def register_translator_module(modl)
+      FastRuby::TranslatorModules.instance.register_translator_module(modl)  
+    end
+end

data/lib/fastruby.rb

@@ -32,5 +32,7 @@ class Object
 end
 
 module FastRuby
-  VERSION = "0.0.19" unless defined? FastRuby::VERSION
+  VERSION = "0.0.20" unless defined? FastRuby::VERSION
 end
+
+require "fastruby/corelib"

data/lib/fastruby.rb~

@@ -32,5 +32,7 @@ class Object
 end
 
 module FastRuby
-  VERSION = "0.0.18" unless defined? FastRuby::VERSION
+  VERSION = "0.0.19" unless defined? FastRuby::VERSION
 end
+
+require "fastruby/corelib"

data/lib/fastruby_only/base.rb

@@ -0,0 +1 @@
+|*x| tree = x.first; 

data/spec/corelib/numeric/fixnum_spec.rb

@@ -0,0 +1,110 @@
+require "fastruby"
+
+describe FastRuby, "fastruby fixnum corelib" do
+  
+  $fixnum_class_num = 0
+  def self.test_op_with_type(recv, op, parameter, expected = recv.send(op, parameter))
+    _classname = "FXNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op}(#{parameter}) should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo(parameter)
+            #{recv}.#{op}(parameter)
+          end
+        end
+      "
+    
+    )
+    
+      eval(_classname).new.foo(parameter).should be == expected
+    end
+    
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  def self.test_op(recv, op, parameter, expected = recv.send(op, parameter))
+    _classname = "FXNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op}(#{parameter}) should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo(parameter)
+            #{recv}.#{op}(parameter.call)
+          end
+        end
+      "
+    
+    )
+    
+      eval(_classname).new.foo( lambda{parameter} ).should be == expected
+    end
+    
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+  
+  def self.test_unary_op(recv, op, expected = recv.send(op))
+    _classname = "FXNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op} should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo
+            #{recv}.#{op}
+          end
+        end
+      "
+    
+    )
+    
+      eval(_classname).new.foo.should be == expected
+    end
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  
+  class CustomValue
+    def method_missing(m,x)
+      42
+    end    
+    def <(x)
+      true
+    end
+
+    def >(x)
+      false
+    end
+    
+    def coerce(other)
+      return self, other
+    end
+  end
+  
+
+  test_methods = [:-@, :abs, :to_f, :size, :zero?, :odd?, :even?, :succ]
+  if RUBY_VERSION =~ /^1\\.9/
+    test_methods << :magnitude
+  end  
+
+  test_methods.each do |op|
+    test_unary_op(31,op)
+    test_unary_op(-31,op)
+  end
+  
+  #TODO: upto, downto, succ, next, pred, chr
+
+  [:+, :-, :<, :>, :/,:div,:%,:modulo,:divmod,:fdiv,:**,:==,:===,:<=>,:>=,:<=].each do |op|
+    [1,1.1,10**10,CustomValue.new].each do |value|
+      test_op_with_type(1,op,value)
+      test_op(1,op,value)
+    end
+  end
+
+  [:&,:|,:^,:[],:<<,:>>].each do |op|
+    [1,2,3].each do |value|
+      test_op_with_type(1,op,value)
+      test_op(1,op,value)
+    end
+  end
+
+end

data/spec/corelib/numeric/fixnum_spec.rb~

@@ -0,0 +1,104 @@
+require "fastruby"
+
+describe FastRuby, "fastruby fixnum corelib" do
+  
+  $fixnum_class_num = 0
+  def self.test_op_with_type(recv, op, parameter, expected = recv.send(op, parameter))
+    _classname = "FXNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op}(#{parameter}) should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo(parameter)
+            #{recv}.#{op}(parameter)
+          end
+        end
+      "
+    
+    )
+    
+      eval(_classname).new.foo(parameter).should be == expected
+    end
+    
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  def self.test_op(recv, op, parameter, expected = recv.send(op, parameter))
+    _classname = "FXNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op}(#{parameter}) should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo(parameter)
+            #{recv}.#{op}(parameter.call)
+          end
+        end
+      "
+    
+    )
+    
+      eval(_classname).new.foo( lambda{parameter} ).should be == expected
+    end
+    
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+  
+  def self.test_unary_op(recv, op, expected = recv.send(op))
+    _classname = "FXNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op} should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo
+            #{recv}.#{op}
+          end
+        end
+      "
+    
+    )
+    
+      eval(_classname).new.foo.should be == expected
+    end
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  
+  class CustomValue
+    def method_missing(m,x)
+      42
+    end    
+    def <(x)
+      true
+    end
+
+    def >(x)
+      false
+    end
+    
+    def coerce(other)
+      return self, other
+    end
+  end
+  
+  [:-@, :abs, :magnitude, :to_f, :size, :zero?, :odd?, :even?, :succ].each do |op|
+    test_unary_op(31,op)
+    test_unary_op(-31,op)
+  end
+  
+  #TODO: upto, downto, succ, next, pred, chr
+
+  [:+, :-, :<, :>, :/,:div,:%,:modulo,:divmod,:fdiv,:**,:==,:===,:<=>,:>=,:<=].each do |op|
+    [1,1.1,10**10,CustomValue.new].each do |value|
+      test_op_with_type(1,op,value)
+      test_op(1,op,value)
+    end
+  end
+
+  [:&,:|,:^,:[],:<<,:>>].each do |op|
+    [1,2,3].each do |value|
+      test_op_with_type(1,op,value)
+      test_op(1,op,value)
+    end
+  end
+
+end

data/spec/corelib/numeric/integer_spec.rb

@@ -0,0 +1,173 @@
+require "fastruby"
+
+describe FastRuby, "fastruby integer corelib" do
+  
+  $fixnum_class_num = 0
+  def self.test_op(recv, op, parameter, expected = recv.send(op, parameter))
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op}(#{parameter}) should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo(parameter)
+            #{recv}.#{op}(parameter.call)
+          end
+        end
+      "
+    
+    )
+    
+      eval(_classname).new.foo( lambda{parameter} ).should be == expected
+    end
+    
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  def self.test_op_block(recv, op, argument)
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    expected = Array.new
+    recv.send(op, argument, &expected.method(:<<))
+    
+    it "receiver #{recv}.#{op} should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo(argument)
+            #{recv}.#{op}(argument.call) do |x|
+              yield(x)
+            end
+          end
+        end
+      "
+    
+    )
+    
+      returned = Array.new
+      eval(_classname).new.foo(lambda{argument},&returned.method(:<<))
+      
+      returned.should be == expected
+    end
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  def self.test_op_enumerator(recv, op, parameter)
+    
+    expected = Array.new
+    recv.send(op, parameter).each(&expected.method(:<<))
+    
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op}(#{parameter}) should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo(parameter)
+            #{recv}.#{op}(parameter.call)
+          end
+        end
+      "
+    
+    )
+    
+      returned_array = Array.new
+      eval(_classname).new.foo( lambda{parameter} ).each(&returned_array.method(:<<))
+
+      returned_array.should be == expected
+    end
+    
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  
+  def self.test_unary_op_block(recv, op)
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    expected = Array.new
+    recv.send(op, &expected.method(:<<))
+    
+    it "receiver #{recv}.#{op} should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo
+            #{recv}.#{op} do |x| yield(x) end
+          end
+        end
+      "
+    
+    )
+    
+      returned = Array.new
+      eval(_classname).new.foo do |x| returned << x end
+      returned.should be == expected
+    end
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+  
+  def self.test_unary_op(recv, op, expected = recv.send(op))
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op} should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo
+            #{recv}.#{op}
+          end
+        end
+      "
+    
+    )
+    
+      eval(_classname).new.foo.should be == expected
+    end
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  def self.test_unary_op_enumerator(recv, op)
+    
+    expected = Array.new
+    recv.send(op).each(&expected.method(:<<))
+    
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op} should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo
+            #{recv}.#{op}
+          end
+        end
+      "
+    
+    )
+    
+      returned_array = Array.new
+      eval(_classname).new.foo.each(&returned_array.method(:<<))
+      
+      returned_array.should be == expected
+    end
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  [:integer?, :odd?, :even?, :succ, :next, :pred, :chr, :ord, :to_i, :to_int, :floor, :ceil, :truncate, :round].each do |op|
+    test_unary_op(32,op)
+    test_unary_op(77,op)
+  end
+  
+  [:times].each do |op|
+    test_unary_op_enumerator(77, op)
+    test_unary_op_block(77, op)
+  end
+
+  test_op_block(77, :upto, 90)
+  test_op_block(77, :downto, 60)
+  test_op_enumerator(77, :upto, 90)
+  test_op_enumerator(77, :downto, 60)
+  
+  it "1.upto(3).to_a should be [1,2,3]" do
+    1.upto(3).to_a.should be == [1,2,3]
+  end
+
+  it "3.downto(1).to_a should be [3,2,1]" do
+    3.downto(1).to_a.should be == [3,2,1]
+  end
+
+end

data/spec/corelib/numeric/integer_spec.rb~

@@ -0,0 +1,173 @@
+require "fastruby"
+
+describe FastRuby, "fastruby integer corelib" do
+  
+  $fixnum_class_num = 0
+  def self.test_op(recv, op, parameter, expected = recv.send(op, parameter))
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op}(#{parameter}) should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo(parameter)
+            #{recv}.#{op}(parameter.call)
+          end
+        end
+      "
+    
+    )
+    
+      eval(_classname).new.foo( lambda{parameter} ).should be == expected
+    end
+    
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  def self.test_op_block(recv, op, argument)
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    expected = Array.new
+    recv.send(op, argument, &expected.method(:<<))
+    
+    it "receiver #{recv}.#{op} should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo(argument)
+            #{recv}.#{op}(argument.call) do |x|
+              yield(x)
+            end
+          end
+        end
+      "
+    
+    )
+    
+      returned = Array.new
+      eval(_classname).new.foo(lambda{argument},&returned.method(:<<))
+      
+      returned.should be == expected
+    end
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  def self.test_op_enumerator(recv, op, parameter)
+    
+    expected = Array.new
+    recv.send(op, parameter).each(&expected.method(:<<))
+    
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op}(#{parameter}) should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo(parameter)
+            #{recv}.#{op}(parameter.call)
+          end
+        end
+      "
+    
+    )
+    
+      returned_array = Array.new
+      eval(_classname).new.foo( lambda{parameter} ).each(&returned_array.method(:<<))
+
+      returned_array.should be == expected
+    end
+    
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  
+  def self.test_unary_op_block(recv, op)
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    expected = Array.new
+    recv.send(op, &expected.method(:<<))
+    
+    it "receiver #{recv}.#{op} should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo
+            #{recv}.#{op} do |x| yield(x) end
+          end
+        end
+      "
+    
+    )
+    
+      returned = Array.new
+      eval(_classname).new.foo do |x| returned << x end
+      returned.should be == expected
+    end
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+  
+  def self.test_unary_op(recv, op, expected = recv.send(op))
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op} should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo
+            #{recv}.#{op}
+          end
+        end
+      "
+    
+    )
+    
+      eval(_classname).new.foo.should be == expected
+    end
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  def self.test_unary_op_enumerator(recv, op)
+    
+    expected = Array.new
+    recv.send(op).each(&expected.method(:<<))
+    
+    _classname = "INTEGERNUMTEST#{$fixnum_class_num}"
+    
+    it "receiver #{recv}.#{op} should return #{expected} #{expected.class}" do
+    fastruby(
+      "class #{_classname}
+          def foo
+            #{recv}.#{op}
+          end
+        end
+      "
+    
+    )
+    
+      returned_array = Array.new
+      eval(_classname).new.foo.each(&returned_array.method(:<<))
+      
+      returned_array.should be == expected
+    end
+    $fixnum_class_num = $fixnum_class_num + 1
+  end
+
+  [:integer?, :odd?, :even?, :succ, :next, :pred, :chr, :ord, :to_i, :to_int, :floor, :ceil, :truncate, :round].each do |op|
+    test_unary_op(32,op)
+    test_unary_op(77,op)
+  end
+  
+  [:times].each do |op|
+    test_unary_op_enumerator(77, op)
+    test_unary_op_block(77, op)
+  end
+
+  test_op_block(77, :upto, 90)
+  test_op_block(77, :downto, 60)
+  test_op_enumerator(77, :upto, 90)
+  test_op_enumerator(77, :downto, 60)
+  
+  it "1.upto(3).to_a should be [1,2,3]" do
+    1.upto(3).to_a.should be == [1,2,3]
+  end
+
+  it "3.downto(1).to_a should be [3,2,1]" do
+    3.downto(1).to_a.should be == [3,2,1]
+  end
+
+end