maroon 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a2b4446ac84c36b68f710a04280f9488d116035c
-  data.tar.gz: 01322628719027b5cfc4b500f81063a23c326e5a
+  metadata.gz: 41c4d573b28bd312c8a720f51ae4b283cd9311bd
+  data.tar.gz: a2a0f21a0278e3af009c884204e18bfa5c633d55
 SHA512:
-  metadata.gz: 8a6644383356d9c8939dd1fa94c89d0e89baa05d867a1c7f2229c335972c04c164d4e6deacbe0632a679453c60858eb3447914817c8d9bc1e6fd7b1a741dd2ae
-  data.tar.gz: ae022ce8665b2c78f963112be9a0635306dc6c47d64110dbde15508bdd690ba975ab3f14d2f1711c94e694d99fba2a19fa9af33a987fa484097992a94a57828d
+  metadata.gz: b2a48a828cc60e7e8e33bb4df82bdfacc6ff6c128f142a08f0fdca0858dfa5c25ffa2647855d20a745a2c1338a9ea08b0b71dc1beed452ac38955e1512317085
+  data.tar.gz: 00111ba32f2d574dc7ccfd1ba1435b241fd17e97736bc5ca573afab56c6463f26a50f67b40839381a2c3b0383aff3073fc535eac7efb05e253e78c215ef69e3c

data/README.md

@@ -41,9 +41,11 @@ Run `rake test` or just `rake` to make the tests run.
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+3. Make your changes to the files in base.
+4. Make sure you can run the default rake task with no errors _twice_
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create new Pull Request
 
 
 Known bugs

data/Rakefile

@@ -8,6 +8,7 @@ Rake::TestTask.new do |t|
 end
 
 task :generate do |t|
+
   require_relative './lib/Context'
   require_relative './lib/maroon/kernel'
   require_relative './lib/build' #use the one in lib. That should be the stable one
@@ -32,7 +33,7 @@ end
 
 task :build_generate do |t|
   require_relative './generated/build' #use the one previously generated
-  Context::generate_files_in('generated') #generate files
+  Context::generate_files_in('lib') #generate files
   `git ls-files ./base/`.split($/).grep(%r{(.)*.rb}).select {|f| require_relative("#{f}")}
 end
 

data/Test/Context_test.rb

@@ -0,0 +1,129 @@
+require 'test/unit'
+require_relative 'test_helper'
+class MaroonInternal
+
+end
+class ContextTest < Test::Unit::TestCase
+
+  def test_role_method_call
+    name = :MyContextRoleMethodCall
+    role_name = :rol
+    Context::define name do
+      role role_name do
+        def rolem(x, y)
+          x+y
+        end
+      end
+      def add(x,y)
+        rol.rolem x,y
+      end
+    end
+
+    assert_equal(7, MyContextRoleMethodCall.new.send(:self_rol_rolem, 3, 4))
+    assert_equal(7, MyContextRoleMethodCall.new.add(3, 4))
+  end
+
+  def test_simple
+    name = :MyContextSimple
+    role_name = :r
+    Context::define name do
+      role role_name do
+      end
+    end
+    assert(Kernel::const_defined? name)
+
+  end
+
+  def test_role_method
+    name = :MyContext
+    role_name = :rol
+    c = Context::define name do
+      role role_name do
+        def rolem
+          0+1
+        end
+      end
+    end
+    assert_equal(1, MyContext.new.send(:self_rol_rolem))
+  end
+
+  def test_role_method_args
+    name = :MyContextArgs
+    role_name = :rol
+    Context::define name do
+      role role_name do
+        def rolem(x, y)
+          x+y
+        end
+      end
+    end
+    assert_equal(7, MyContextArgs.new.send(:self_rol_rolem, 3, 4))
+  end
+
+  def test_role_method_splat
+    name = :MyContextSplat
+    role_name = :rol
+    Context::define name do
+      role role_name do
+        def rolem(x, *args)
+          x+(args[0])
+        end
+      end
+    end
+    assert_equal(7, MyContextSplat.new.send(:self_rol_rolem, 3, 4))
+  end
+
+  def test_role_method_block
+    name = :MyContextBlock
+    role_name = :rol
+    Context::define name do
+      role role_name do
+        def rolem(*args, &b)
+          res = 0
+          args.each { |x|
+            res = b.call res, x
+          }
+          res
+        end
+      end
+    end
+    assert_equal(7, MyContextBlock.new.send(:self_rol_rolem, 3, 4) { |x, res| res + x })
+  end
+
+  def test_class_method_block
+    name = :MyContextClass
+    role_name = :rol
+    Context::define name do
+      role :dummy do end
+      role role_name do
+        def rolem(*args, &b)
+          res = 0
+          args.each { |x|
+            res = b.call res, x
+          }
+          res
+        end
+      end
+
+      def self.mul(x, y)
+        x*y
+      end
+
+      def power(x, y)
+        x**y
+      end
+
+      def self.pow(x,y)
+        x**y
+      end
+    end
+    ctx = MyContextClass.new
+
+
+    assert_equal(8, ctx.power(2, 3))
+    assert_equal(16, MyContextClass::pow(2, 4))
+    assert_equal(12, MyContextClass::mul(3, 4))
+    assert_equal(7, ctx.send(:self_rol_rolem, 3, 4) { |x, res| res + x })
+  end
+
+end

data/Test/ImmutableQueue_test.rb

@@ -1,6 +1,6 @@
 require 'test/unit'
 require_relative '../generated/ImmutableQueue'
-
+require_relative '../Test/test_helper'
 
 
 class ImmutableQueueTest < Test::Unit::TestCase
@@ -8,11 +8,11 @@ class ImmutableQueueTest < Test::Unit::TestCase
   def test_sunny
     queue = ImmutableQueue::empty.push 1
     queue = queue.push(2)
-    f,queue = queue.pop()
+    f, queue = queue.pop()
     refute_nil(queue)
-    s,queue = queue.pop()
-    assert_equal(1,f)
-    assert_equal(2,s)
+    s, queue = queue.pop()
+    assert_equal(1, f)
+    assert_equal(2, s)
     assert_equal(ImmutableQueue::empty, queue)
   end
 end

data/Test/MethodInfo_test.rb

@@ -5,61 +5,82 @@ require_relative 'test_helper'
 
 class MethodInfoTest < Test::Unit::TestCase
   include SourceAssertions
+   def get_def(&b)
+     (get_sexp &b).detect do |exp|
+       exp[0] == :defn || exp[0] == :defs
+     end
+   end
+
   def test_simple
-    block = get_sexp do |a,b|
-      p 'this is a test'
+    block = get_def  do
+      def name (a, b)
+        p 'this is a test'
+      end
     end
-    source = MethodInfo.new(false,block,true).build_as_context_method("name",InterpretationContext.new({},{},{},nil))
-    expected = %{def name(a,b)
-       p("this is a test")
+
+    source = MethodInfo.new( block,nil,false).build_as_context_method( InterpretationContext.new({}, {}, {}, nil))
+    expected ='def name(a,b)    p("this is a test") end'
+    assert_source_equal(expected, source)
+  end
+
+  def test_rolemethod
+    block = get_def  do
+      def name (a, b)
+        foo.bar
+      end
     end
-}
-    assert_source_equal(expected,source)
+
+    source = MethodInfo.new( block,nil,false).build_as_context_method( InterpretationContext.new({:foo=>{:bar=>[]}}, {}, {}, nil))
+    expected ='def name(a,b)    self_foo_bar end'
+    assert_source_equal(expected, source)
   end
+
   def test_class_method
-    block = get_sexp do |a,b|
-      p 'this is a test'
+    block = get_def do
+      def self.name(a, b)
+        p 'this is a test'
+      end
     end
-    source = MethodInfo.new(self,block,true).build_as_context_method("name",InterpretationContext.new({},{},{},nil))
-    expected = %{def self.name(a,b)
-       p("this is a test")
-    end
-}
-    assert_source_equal(expected,source)
+
+    source = MethodInfo.new( block,nil,false).build_as_context_method( InterpretationContext.new({}, {}, {}, nil))
+    expected = 'def self.name(a,b)  p("this is a test") end'
+
+    assert_source_equal(expected, source)
   end
 
   def test_splat_argument
-    block = get_sexp do |a,*b|
+    block = get_def do
+      def name (a, *b)
       p 'this is a test'
+      end
     end
-    source = MethodInfo.new(nil,block,true).build_as_context_method("name",InterpretationContext.new({},{},{},nil))
-    expected = %{def name(a,*b)
-       p("this is a test")
-    end
-}
-    assert_source_equal(expected,source)
+    source = MethodInfo.new( block,nil,false).build_as_context_method( InterpretationContext.new({}, {}, {}, nil))
+    expected = 'def name(a,*b) p("this is a test") end'
+    assert_source_equal(expected, source)
   end
 
   def test_block_argument
-    block = get_sexp do |a,b|
+    block = get_def do
+     def name(a, b,&block)
       p 'this is a test'
+     end
     end
-    source = MethodInfo.new({:block=>:block},block,true)
-    source = source.build_as_context_method("name",InterpretationContext.new({},{},{},nil))
-    expected = %{def name(a,b,&block)
-       p("this is a test")
-    end
-}
-    assert_source_equal(expected,source)
+
+    source = MethodInfo.new( block,nil,false)
+    source = source.build_as_context_method(InterpretationContext.new({}, {}, {}, nil))
+    expected = 'def name(a,b,&block)    p("this is a test")  end'
+
+    assert_source_equal(expected, source)
   end
+
   def test_block_argument_class_method
-    block = (get_sexp { |a,*b|
-      p 'is a test'    })
-    source = MethodInfo.new({:block=>:block,:self=>self},block,true).build_as_context_method("name",InterpretationContext.new({},{},{},nil))
-    expected = %{def self.name(a,*b,&block)
-       p("this is a test")
+    block = get_def do
+      def self.name(a, *b,&block)
+        p 'is a test'
+      end
     end
-}
-    assert_source_equal(expected,source)
+    source = MethodInfo.new( block,nil,false).build_as_context_method( InterpretationContext.new({}, {}, {}, nil))
+    expected = 'def self.name(a,*b,&block) p("is a test") end'
+    assert_source_equal(expected, source)
   end
 end

data/Test/alltests.rb

@@ -1 +1 @@
-`git ls-files`.split($/).grep(%r{(test|spec|features).rb}).select {|f| p f; require_relative("../#{f}")}
+`git ls-files`.split($/).grep(%r{(test|spec|features).rb}).select { |f| p f; require_relative("../#{f}") }

data/Test/assertions.rb

@@ -4,14 +4,22 @@ require 'ruby2ruby'
 module SourceAssertions
   def assert_source_equal(expected, actual)
 
-    expected_sexp = if expected.instance_of? String then Ripper::sexp expected else expected end
-    actual_sexp =  if actual.instance_of? String then Ripper::sexp actual else actual end
+    expected_sexp = if expected.instance_of? String then
+                      Ripper::sexp expected
+                    else
+                      expected
+                    end
+    actual_sexp = if actual.instance_of? String then
+                    Ripper::sexp actual
+                  else
+                    actual
+                  end
 
     message = "
     Expected: #{expected}
     but got:  #{actual}"
     assert_sexp_with_ident(expected_sexp, actual_sexp, message)
-    assert_equal(1,1) #just getting the correct assertion count
+    assert_equal(1, 1) #just getting the correct assertion count
   end
 
   def is_terminal(sexp)
@@ -40,7 +48,7 @@ module SourceAssertions
         end
       else
         if expected[i] != actual[i]
-          assert_equal(expected[i],actual[i], message || "the arrays differ at index #{i}")
+          assert_equal(expected[i], actual[i], message || "the arrays differ at index #{i}")
         end
       end
     end

data/Test/production_test.rb

@@ -0,0 +1,42 @@
+require 'test/unit'
+require_relative '../generated/Tokens'
+require_relative '../generated/Production'
+require_relative 'test_helper'
+class ProductionTest < Test::Unit::TestCase
+  def get_method_call &b
+    exp = get_sexp &b
+    exp[3]
+  end
+
+  def test_rolemethod
+    method_call = get_method_call { foo.bar }
+
+    production = get_production(method_call)
+    type = production.type
+    assert_equal(Tokens::rolemethod_call, type)
+  end
+
+  def get_production(method_call)
+    contracts ={}
+    roles = {:foo => {:bar => []}}
+    Production.new(method_call, InterpretationContext.new(roles, contracts, nil, nil))
+  end
+
+  def test_call
+    method_call = get_method_call { foo.baz }
+
+    production = get_production(method_call)
+    type = production.type
+
+    assert_equal(Tokens::call, type)
+  end
+
+  def test_indexer
+    method_call = get_method_call { foo[0] }
+
+    production = get_production(method_call)
+    type = production.type
+
+    assert_equal(Tokens::indexer, type)
+  end
+end

data/Test/stack_test.rb

@@ -1,17 +1,16 @@
 require 'test/unit'
 require_relative '../generated/ImmutableStack'
 
-ImmutableStack.new nil,nil
 
 class Stack_Test < Test::Unit::TestCase
 
   def test_push_pop
     stack = ImmutableStack.empty.push(1)
     stack = stack.push 2
-    f,stack = stack.pop
-    s,stack = stack.pop
-    assert_equal(2,f)
-    assert_equal(1,s)
-    assert_equal(stack,ImmutableStack::empty)
+    f, stack = stack.pop
+    s, stack = stack.pop
+    assert_equal(2, f)
+    assert_equal(1, s)
+    assert_equal(stack, ImmutableStack::empty)
   end
 end

data/Test/test_helper.rb

@@ -1,12 +1,12 @@
 require 'minitest/autorun'
 require 'sourcify'
 require_relative 'assertions'
-require_relative '../generated/interpretation_context'
+require_relative '../generated/build'
 #require 'debugger'
 
 def get_sexp &b
   begin
-     b.to_sexp
+    b.to_sexp
   rescue
     puts "failed to get expression"
   end

data/base/AstRewritter.rb

@@ -0,0 +1,63 @@
+context :AstRewritter do
+  role :ast do
+  end
+
+  def initialize (ast, interpretation_context)
+    @ast = Production.new ast, interpretation_context
+  end
+
+  def rewrite!
+    ast.each { |production|
+
+      case production.type
+        when Tokens::rolemethod_call
+          data = production.data
+          production[2] = ('self_' + data[1].to_s + '_' + data[0].to_s).to_sym
+          production[1] = nil
+        when Tokens::block_with_bind
+          block = production.last
+          must_b_sym = 'aliased_role must be a Symbol'.to_sym
+          local_must_b_sym = 'local must be a Symbol'.to_sym
+          raise must_b_sym unless aliased_role.instance_of? Symbol
+          raise local_must_b_sym unless local.instance_of? Symbol
+          # assigning role player to role field
+          #notice that this will be executed after the next block
+          aliased_field = ('@' + aliased_role.to_s).to_sym
+          temp_symbol = ('temp____' + aliased_role.to_s).to_sym
+
+          assignment = Sexp.new
+          assignment[0] = :iasgn
+          assignment[1] = aliased_field
+          load_arg = Sexp.new
+          load_arg[0] = :lvar
+          load_arg[1] = local
+          assignment[2] = load_arg
+          block.insert 1, assignment
+
+          # assign role player to temp
+          # notice this is prepended Ie. inserted in front of the role player to role field
+          assignment = Sexp.new
+          assignment[0] = :lasgn
+          assignment[1] = temp_symbol
+          load_field = Sexp.new
+          load_field[0] = :ivar
+          load_field[1] = aliased_field
+          assignment[2] = load_field
+          block.insert 1, assignment
+
+          # reassign original player
+          assignment = Sexp.new
+          assignment[0] = :iasgn
+          assignment[1] = aliased_field
+          load_temp = Sexp.new
+          load_temp[0] = :lvar
+          load_temp[1] = temp_symbol
+          assignment[2] = load_temp
+          block[block.length] = assignment
+        else
+          #do nothing
+      end
+    }
+  end
+
+end