maroon 0.6.1 → 0.6.5

data/Test/alltests.rb

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

data/Test/{source_assertions.rb → assertions.rb}

@@ -1,13 +1,21 @@
-module Source_assertions
+require 'ripper'
+require 'ruby2ruby'
+
+module SourceAssertions
   def assert_source_equal(expected, actual)
-    expected_sexp = Ripper::sexp expected
-    actual_sexp = Ripper::sexp actual
-    assert_sexp_with_ident(expected_sexp, actual_sexp, "Expected #{expected} but got #{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
+
+    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
   end
 
   def is_terminal(sexp)
-    sexp == :@ident || sexp == :@int || sexp == :@ivar
+    sexp == :@ident || sexp == :@int || sexp == :@ivar || :@tstring_content
   end
 
   def assert_sexp_with_ident(expected, actual, message)
@@ -28,11 +36,11 @@ module Source_assertions
         if actual[i].instance_of? Array
           assert_sexp_with_ident(expected[i], actual[i], message)
         else
-          assert_fail(message || "the arrays differ at index #{i}. Actual was an element but an array was expected")
+          refute(true, message || "the arrays differ at index #{i}. Actual was an element but an array was expected")
         end
       else
         if expected[i] != actual[i]
-          assert_fail (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/bind_test.rb

@@ -0,0 +1,13 @@
+require_relative '../generated/bind'
+require_relative 'test_helper'
+
+class Bind_test < MiniTest::Unit::TestCase
+  def test_sunny
+    block = Sexp.new
+    Bind.new(:role, :alias, block).execute
+    assert_equal(nil, block[0])
+    assert_equal(:@alias, block[1][2][1])
+    assert_equal(:role, block[2][2][1])
+    assert_equal(:@alias, block.last()[1])
+  end
+end

data/Test/expression_test.rb

@@ -0,0 +1,105 @@
+require_relative '../generated/MethodDefinition'
+require_relative 'test_helper'
+require 'ripper'
+
+class Expression_test < MiniTest::Unit::TestCase
+  include SourceAssertions
+  def get_context
+    contracts = {}
+    roles = {:foo=>{:bar=>nil},:baz=>{:rolemethod=>nil},:role=>{}}
+    aliases = {}
+    InterpretationContext.new(roles,contracts,aliases,:role)
+  end
+  def assert_transform(expected,block)
+    raise "No block" unless block
+
+    ctx = get_context
+    md = MethodDefinition.new(block,ctx)
+    md.transform
+
+    assert_source_equal(expected,block)
+    ctx
+  end
+  def test_method_call
+    block = (get_sexp { baz.rolemethod })[3]
+
+    expected = (get_sexp { self_baz_rolemethod })[3]
+
+    assert_transform(expected,block)
+  end
+  def test_index
+    block = (get_sexp do
+      self[0]
+    end)[3]
+    expected = (get_sexp do
+      role[0]
+    end)[3]
+    ctx = assert_transform(expected,block)
+    assert_equal(1,ctx.contracts[:role][:[]])
+  end
+  def test_bind
+    block =  get_sexp do [].each do |r|
+      bind :r=>:foo
+      r.bar
+      foo.baz
+    end
+    end
+    expected = (get_sexp do
+      [].each do |r|
+        temp____foo = @foo
+        @foo = r
+        self_foo_bar
+        foo.baz
+        @foo = temp____foo
+      end
+    end)
+    assert_transform(expected,block)
+  end
+
+  def test_sunny
+    block = get_sexp do
+      [].each do |r|
+        bind :r => :foo
+        r.bar
+        r.baz
+        baz.rolemethod
+        self[boo]
+      end
+      self[0]
+    end
+    expected = (get_sexp do
+      [].each do |r|
+        temp____foo = @foo
+        @foo = r
+        self_foo_bar
+        r.baz
+        self_baz_rolemethod
+        role[boo]
+        @foo = temp____foo
+      end
+      role[0]
+    end)
+
+    interpretation_context = get_context
+    MethodDefinition.new(block,interpretation_context).transform
+    assert_source_equal(expected,block)
+    contracts = interpretation_context.contracts
+    assert_equal(2,contracts.length)
+    assert(contracts[:role].has_key? :[])
+    assert_equal(1,contracts[:role].length)
+    assert(contracts[:foo].has_key? :baz)
+    assert_nil(contracts[:baz])
+  end
+
+  def test_nested_lambda
+
+    block = (get_sexp {lambda {
+      lambda {baz.rolemethod}}.call})
+
+    expected = (get_sexp {lambda {
+      lambda {self_baz_rolemethod}}.call})
+
+    assert_transform(expected,block)
+  end
+
+end

data/Test/method_call_test.rb

@@ -0,0 +1,83 @@
+require_relative '../generated/MethodCall'
+require_relative 'test_helper'
+
+class Method_call_test  < MiniTest::Unit::TestCase
+  def get_method_call &b
+    exp = get_sexp &b
+    exp[3]
+  end
+  include SourceAssertions
+  def test_adding_to_contracts_no_role
+    method_call = get_method_call {foo.bar}
+
+    contracts ={}
+    MethodCall.new(method_call,  InterpretationContext.new({},contracts,nil,nil)).rewrite_call?
+    assert_nil(contracts[nil]) #wasn't a role
+  end
+
+  def test_adding_to_contracts_with_role
+    method_call = get_method_call {foo.bar}
+
+    contracts ={}
+    roles = Hash.new
+    roles[:foo] = Hash.new
+    MethodCall.new(method_call, InterpretationContext.new(roles,contracts,nil,nil)).rewrite_call?
+    assert_equal(1,contracts.length)
+    assert_equal(1, contracts[:foo].length)
+    assert_equal(1, contracts[:foo][:bar])
+  end
+  def test_role_methods_not_added_to_contracts
+    method_call = get_method_call {foo.bar}
+
+    contracts ={}
+    roles = Hash.new
+    roles[:foo] = {:bar => nil}
+    MethodCall.new(method_call,  InterpretationContext.new(roles,contracts,nil,nil)).rewrite_call?
+    assert_equal(0,contracts.length)
+    assert_source_equal(get_method_call {self_foo_bar},method_call)
+  end
+
+  def test_contract_and_bind
+    block =get_sexp do [].each do |r|
+        temp____foo = @foo
+        @foo = r
+        r.bar
+        foo.baz
+      @foo = temp____foo
+      end
+    end
+
+    contracts ={}
+    roles = {:foo=> {:bar => nil},:role=>{}}
+    methodcall1 = block[3][3][3]
+    methodcall2 = block[3][3][4]
+    expected1 = get_method_call {self_foo_bar}
+    expected2 = get_method_call {foo.baz}
+
+    MethodCall.new(methodcall1, InterpretationContext.new(roles,contracts,{:r=>:foo},:role)).rewrite_call?
+    MethodCall.new(methodcall2, InterpretationContext.new(roles,contracts,{:r=>:foo},:role)).rewrite_call?
+
+    assert_source_equal(expected2,methodcall2)
+    assert_source_equal(expected1,methodcall1)
+    assert_equal(1,contracts.length)
+    assert_equal(1,contracts[:foo].length)
+    assert_equal(1,contracts[:foo][:baz])
+    assert_nil(contracts[:bar])
+  end
+  def test_index_contracts
+    methodcall = (get_sexp do
+      role[boo]
+    end)[3]
+
+    contracts = {}
+    roles = {:foo=>{:bar=>nil},:baz=>{:rolemethod=>nil},:role=>{}}
+    aliases = {}
+    interpretation_context = InterpretationContext.new(roles,contracts,aliases,:role)
+    mc = MethodCall.new(methodcall, interpretation_context)
+    mc.rewrite_call?
+
+    assert_equal(1,contracts.length)
+    assert_equal(1,interpretation_context.contracts[:role].length)
+    assert_equal(1,interpretation_context.contracts[:role][:[]])
+  end
+end

data/Test/self_test.rb

@@ -0,0 +1,46 @@
+require_relative '../generated/self'
+require_relative 'test_helper'
+
+require 'ruby2ruby'
+
+class Self_test < MiniTest::Unit::TestCase
+  include SourceAssertions
+  def assert_self(abstract_syntax_tree, defining_role)
+     assert_equal(:call,abstract_syntax_tree[0])
+     assert_nil(abstract_syntax_tree[1])
+     assert_equal(defining_role, abstract_syntax_tree[2])
+     assert_instance_of(Sexp,abstract_syntax_tree[3])
+     assert_equal(abstract_syntax_tree[3][0], :arglist)
+  end
+  def interpretation_context
+    InterpretationContext.new({:role=>{}},nil,nil,:role)
+  end
+  def test_sunny
+    ast = (get_sexp { self.bar })[3]
+
+    Self.new(ast[1],interpretation_context).execute
+
+    expected = (get_sexp { role.bar })[3]
+    assert_source_equal(expected,ast)
+  end
+
+  def test_indexer
+    ast = (get_sexp {self[0]})[3]
+
+    Self.new(ast,interpretation_context).execute
+
+    expected = (get_sexp { role[0] })[3]
+    assert_source_equal(expected,ast)
+  end
+
+  def test_as_index
+    ast = (get_sexp {bar[self]})[3]
+
+    Self.new(ast[3],interpretation_context).execute
+
+    expected = (get_sexp { bar[role] })[3]
+    refute_nil(ast)
+    refute_equal(0,ast.length)
+    assert_source_equal(expected,ast)
+  end
+end

data/Test/stack_test.rb

@@ -0,0 +1,17 @@
+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)
+  end
+end

data/Test/test_helper.rb

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

data/base/ImmutableStack.rb

@@ -0,0 +1,32 @@
+context :ImmutableStack do
+  role :head do
+  end
+  role :tail do
+  end
+  pop do
+    [@head, @tail]
+  end
+  push do |element|
+    ImmutableStack.new element, self
+  end
+
+  empty self do
+    @@empty ||= self.new(nil, nil)
+  end
+
+  each do
+    yield head
+    t = tail
+    while t != ImmutableStack::empty do
+      h, t = t.pop
+      yield h
+    end
+  end
+
+  initialize do |h, t|
+    @head = h
+    @tail = t
+    self.freeze
+  end
+end
+

data/base/MethodDefinition.rb

@@ -0,0 +1,124 @@
+context :MethodDefinition, :transform do
+
+  rebind do
+    @exp, @expressions = expressions.pop
+    @block, @potential_bind = nil
+    if @exp && (@exp.instance_of? Sexp) && @exp[0] == :iter
+      @exp[1..-1].each do |expr|
+        #find the block
+        if expr && expr.length && expr[0] == :block
+          @block, @potential_bind = expr, expr[1]
+        end
+      end
+    end
+    @expressions = if @exp.instance_of? Sexp then
+                     @expressions.push_array(exp)
+                   else
+                     @expressions
+                   end
+  end
+
+  transform do
+    #could have been recursive but the stack depth isn't enough for even simple contexts
+    until expressions.empty?
+
+      block.transform
+      if exp && (exp.instance_of? Sexp)
+        is_indexer = exp[0] == :call && exp[1] == nil && (exp[2] == :[] || exp[2] == :[]=)
+        if  (is_indexer || (exp[0] == :self)) && @interpretation_context.defining_role
+          Self.new(exp, interpretation_context).execute
+        end
+        if exp[0] == :call
+          MethodCall.new(exp, interpretation_context).rewrite_call?
+        end
+      end
+      rebind
+    end
+  end
+
+  initialize do |exp, interpretationcontext|
+    no_exp = 'No expression supplied'.to_sym
+    no_ctx = 'No interpretation context'.to_sym
+
+    raise no_exp unless exp
+    raise no_ctx unless interpretationcontext
+
+    @interpretation_context = interpretationcontext
+    @expressions = ImmutableQueue::empty.push exp
+    rebind
+  end
+
+  role :interpretation_context do
+    addalias do |key, value|
+      @interpretation_context.role_aliases[key] = value
+    end
+  end
+  role :exp do
+  end
+  role :expressions do
+    empty? do
+      expressions == ImmutableQueue::empty
+    end
+  end
+  role :potential_bind do
+    is_bind? do
+      potential_bind &&
+          potential_bind.length &&
+          (potential_bind[0] == :call &&
+              potential_bind[1] == nil &&
+              potential_bind[2] == :bind)
+    end
+  end
+  role :block do
+    ##
+    #Transforms blocks as needed
+    #-Rewrites self in role methods to the role getter
+    #-Rewrites binds when needed
+    #-Rewrites role method calls to instance method calls on the context
+    ##
+    transform {
+      if block
+        if block.transform_bind?
+          @expressions.push_array(block[1..-1])
+        end
+      end
+    }
+    ##
+    #Calls rewrite_block if needed and will return true if the AST was changed otherwise false
+    ##
+    transform_bind? {
+      #check if the first call is a bind call
+      potential_bind.is_bind? && block.rewrite
+    }
+
+    rewrite {
+      changed = false
+      arguments = potential_bind[3]
+
+        if arguments && arguments[0] == :hash
+          block.delete_at 1
+          count = (arguments.length-1) / 2
+          (1..count).each do |j|
+            temp = j * 2
+            local = arguments[temp-1][1]
+            if local.instance_of? Sexp
+              local = local[1]
+            end
+            raise 'invalid value for role alias' unless local.instance_of? Symbol
+            #find the name of the role being bound to
+            aliased_role = arguments[temp][1]
+            if aliased_role.instance_of? Sexp
+              aliased_role = aliased_role[1]
+            end
+            raise aliased_role.to_s + 'used in binding is an unknown role ' + roles.to_s unless aliased_role.instance_of? Symbol and interpretation_context.roles.has_key? aliased_role
+            interpretation_context.addalias local, aliased_role
+            #replace bind call with assignment of iteration variable to role field
+            Bind.new(local, aliased_role, block).execute
+            changed = true
+          end
+        end
+      changed
+    }
+  end
+
+end