maroon 0.5.3 → 0.6.0

data/Examples/Dijkstra/calculate_shortest_path.rb

@@ -1,6 +1,4 @@
 # -*- encoding: utf-8 -*-
-require 'live_ast'
-require 'live_ast/to_ruby'
 #
 # Consider street corners on a Manhattan grid. We want to find the
 # minimal path from the most northeast city to the most
@@ -352,5 +350,5 @@ class CalculateShortestPath
   end
 end
 
- File.open('CalculateShortestPath_generated.rb', 'w') {|f| f.write(source) }
+File.open('CalculateShortestPath_generated.rb', 'w') {|f| f.write(source) }
 

data/Examples/Dijkstra/dijkstra.rb

@@ -1,8 +1,8 @@
 # -*- encoding: utf-8 -*-
-require '../../Lib/maroon.rb'
-require './data.rb'
-require './CalculateShortestDistance.rb'
-require './Calculate_Shortest_Path.rb'
+require './Lib/maroon.rb'
+require './Examples/Dijkstra/data.rb'
+require './Examples/Dijkstra/CalculateShortestDistance.rb'
+require './Examples/Dijkstra/Calculate_Shortest_Path.rb'
 #!/usr/bin/env ruby
 # Example in Ruby -- Dijkstra's algorithm in DCI
 #    Modified and simplified for a Manhattan geometry with 8 roles

data/Examples/MoneyTransfer.rb

@@ -1,4 +1,4 @@
-require '../lib/maroon.rb'
+require './lib/maroon.rb'
 
 Context::define :MoneyTransfer do
   role :source do

data/Test/Greeter_test.rb

@@ -1,12 +1,91 @@
-require "test/unit"
-require '../lib/maroon.rb'
-require '../lib/maroon/kernel.rb'
+require 'test/unit'
+require './lib/maroon.rb'
+require './lib/maroon/kernel.rb'
+require 'ripper'
+require './Test/source_assertions.rb'
+
+
+class BasicTests < Test::Unit::TestCase
+  include Source_assertions
+
+  def test_define_context
+    name = :MyContext
+    ctx, source = Context::define name do
+    end
+    assert_equal(ctx.name, "Kernel::#{name}")
+    assert_equal(source, "class #{name}\r\n\n\n  private\n\n\n\r\nend")
+  end
+
+  def test_base_class
+    name = :MyDerivedContext
+    ctx,source = context name, Person do
+    end
+    obj = MyDerivedContext.new
+    obj.name = name
+    assert_equal(ctx.name, "Kernel::#{name}")
+    assert_not_nil(obj.name)
+    assert((obj.class < Person), 'Object is not a Person')
+    assert_equal(name, obj.name)
+  end
+
+  def test_define_role
+    name, role_name = :MyContextWithRole, :my_role
+    ctx, source = Context::define name do
+      role role_name do
+        role_go_do do
+
+        end
+      end
+    end
+    assert_not_nil(ctx)
+    assert_equal(ctx.name, "Kernel::#{name}")
+    assert_source_equal("class #{name}\r\n\n@#{role_name}\n\n  private\ndef #{role_name};@#{role_name} end\n\n  \ndef self_#{role_name}_role_go_do \n end\n\n\r\nend", source)
+  end
+
+  def test_args_on_role_method
+    name, role_name = :MyContextWithRoleAndArgs, :my_role
+    ctx, source = Context::define name do
+      role role_name do
+        role_go_do do |x,y|
+
+        end
+        role_go do |x|
+
+        end
+      end
+    end
+    assert_not_nil(ctx)
+    assert_equal(ctx.name, "Kernel::#{name}")
+    assert_source_equal("class #{name}\r\n\n@#{role_name}\n\n  private\ndef #{role_name};@#{role_name} end\n\n  \ndef self_#{role_name}_role_go_do(x,y) \n end\n\ndef self_#{role_name}_role_go(x) \n end\n\n\r\nend", source)
+  end
+
+  def test_bind
+    name, other_name = :MyContextUsingBind, :other_role
+    ctx, source = Context::define name do
+      role other_name do
+        plus_one do
+          (self + 1)
+        end
+      end
+      go_do do
+        a = Array.new
+        [1, 2].each do |e|
+          bind e => :other_role
+          a << e.plus_one
+        end
+        a
+      end
+    end
+    arr = MyContextUsingBind.new.go_do
+    assert_not_nil(ctx)
+    assert_equal(ctx.name, "Kernel::#{name}")
+    expected = "class MyContextUsingBind\r\n  \ndef go_do \na = Array.new\n  [1, 2].each do |e|\n    temp____other_role = @other_role\n    @other_role = e\n    (a << self_other_role_plus_one)\n    @other_role = temp____other_role\n  end\n  a\n end\n\n@other_role\n\n  private\ndef other_role;@other_role end\n\n  \ndef self_other_role_plus_one \n(other_role + 1)  end\n\n\r\nend"
+    assert_source_equal(expected, source)
+    assert_equal(2, arr[0])
+    assert_equal(3, arr[1])
+  end
+end
 
-##
-# General comment
-# it's hopeless to test for the actual source. It should be the syntax tree rather than the source
-# it's the semantics that are important not the formatted source!!
-##
 
 context :Greet_Someone, :greet do
   role :greeter do
@@ -23,6 +102,23 @@ context :Greet_Someone, :greet do
   end
 end
 
+context :Greet_Someone2, :greet do
+  role :greeter do
+    welcome do
+      self.greeting
+    end
+  end
+
+  role :greeted do
+  end
+
+  greet do |msg|
+    a = "#{greeter.name}: \"#{greeter.welcome}, #{greeted.name}!\" #{msg}"
+    p a
+    a
+  end
+end
+
 class Person
   attr_accessor :name
   attr_accessor :greeting
@@ -36,73 +132,59 @@ class Greet_Someone
   end
 end
 
-class BasicTests < Test::Unit::TestCase
-
-  def test_define_context
-    name = :MyContext
-    ctx,source = Context::define name do end
-    assert_equal(ctx.name, "Kernel::#{name}")
-    assert_equal(source,"class #{name}\r\n\n\n  private\n\n\n\r\nend")
-  end
-
-  def test_define_role
-    name,role_name = :MyContextWithRole,:my_role
-    ctx,source = Context::define name do
-      role role_name do
-        role_go_do do
-
-        end
-      end
-    end
-    assert_not_nil(ctx)
-    assert_equal(ctx.name, "Kernel::#{name}")
-    assert_equal("class #{name}\r\n\n@#{role_name}\n\n  private\ndef #{role_name};@#{role_name} end\n\n  \ndef self_#{role_name}_role_go_do \n end\n\n\r\nend",source)
+class Greet_Someone2
+  def initialize(greeter, greeted)
+    @greeter = greeter
+    @greeted = greeted
   end
+end
 
-  def test_bind
-    name,role_name,other_name = :MyContextUsingBind,:my_role, :other_role
-    ctx,source = Context::define name do
-      role other_name do
-          plus_one do
-             (self + 1)
-          end
-      end
-      go_do do
-             a = Array.new
-             [1,2].each do |e|
-                  bind e => :other_role
-                  a << e.plus_one
-             end
-          a
-       end
-    end
-    arr = MyContextUsingBind.new.go_do
-    assert_not_nil(ctx)
-    assert_equal(ctx.name, "Kernel::#{name}")
-    assert_equal("class MyContextUsingBind\r\n  \ndef go_do \na = Array.new\n  [1, 2].each do |e|\n    temp____other_role = @other_role\n    @other_role = e\n    (a << self_other_role_plus_one)\n    @other_role = temp____other_role\n  end\n  a\n end\n\n@other_role\n\n  private\ndef other_role;@other_role end\n\n  \ndef self_other_role_plus_one \n(other_role + 1)  end\n\n\r\nend",source)
-    assert_equal(2,arr[0])
-    assert_equal(3,arr[1])
+class TestExamples < Test::Unit::TestCase
+  def test_greeter
+    p1 = Person.new
+    p1.name = 'Bob'
+    p1.greeting = 'Hello'
+
+    p2 = Person.new
+    p2.name = 'World!'
+    p2.greeting = 'Greetings'
+
+    #Execute is automagically created for the default interaction (specified by the second argument in context :Greet_Someone, :greet do)
+    #Executes constructs a context object and calls the default interaction on this object
+    res1 = Greet_Someone.call p1, p2
+    res2 = Greet_Someone.new(p2, p1).greet
+    res3 = Greet_Someone.new(p2, p1).call
+    assert_equal(res1, "#{p1.name}: \"#{p1.greeting}, #{p2.name}!\"")
+    assert_equal(res1, Greet_Someone.new(p1, p2).greet) #verifies default action
+    #constructs a Greet_Someone context object and executes greet.
+    assert_equal(res2, "#{p2.name}: \"#{p2.greeting}, #{p1.name}!\"")
+    assert_equal(res2, res3)
   end
 end
 
+
 class TestExamples < Test::Unit::TestCase
-   def test_greeter
-     p1 = Person.new
-     p1.name = 'Bob'
-     p1.greeting = 'Hello'
-
-     p2 = Person.new
-     p2.name = 'World!'
-     p2.greeting = 'Greetings'
-
-     #Execute is automagically created for the default interaction (specified by the second argument in context :Greet_Someone, :greet do)
-     #Executes construc a context object and calls the default interaction on this object
-     res1 = Greet_Someone.execute p1, p2
-     res2 = Greet_Someone.new(p2, p1).greet
-     assert_equal(res1,"#{p1.name}: \"#{p1.greeting}, #{p2.name}!\"")
-     assert_equal(res1,Greet_Someone.new(p1, p2).greet) #verifies default action
-     #constructs a Greet_Someone context object and executes greet.
-     assert_equal(res2,"#{p2.name}: \"#{p2.greeting}, #{p1.name}!\"")
-   end
+  def test_greeter
+    p1 = Person.new
+    p1.name = 'Bob'
+    p1.greeting = 'Hello'
+
+    p2 = Person.new
+    p2.name = 'World!'
+    p2.greeting = 'Greetings'
+
+    message = ' Nice weather, don\'t you think?'
+    res1 = Greet_Someone2.call p1, p2, message
+    res2 = Greet_Someone2.new(p2, p1).greet message
+    res3 = Greet_Someone2.new(p2, p1).call message
+    assert_equal(res1, "#{p1.name}: \"#{p1.greeting}, #{p2.name}!\" #{message}")
+    assert_equal(res1, Greet_Someone2.new(p1, p2).greet(message)) #verifies default action
+                                                                  #constructs a Greet_Someone context object and executes greet.
+    assert_equal(res2, "#{p2.name}: \"#{p2.greeting}, #{p1.name}!\" #{message}")
+    assert_equal(res2, res3)
+  end
 end
 
+
+
+

data/Test/source_assertions.rb

@@ -0,0 +1,40 @@
+module Source_assertions
+  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}")
+    assert_equal(1,1) #just getting the correct assertion count
+  end
+
+  def is_terminal(sexp)
+    sexp == :@ident || sexp == :@int || sexp == :@ivar
+  end
+
+  def assert_sexp_with_ident(expected, actual, message)
+    if is_terminal expected[0]
+      if expected[-1].instance_of? Array
+        if actual[-1].instance_of? Array
+          if actual[-1].length == 2
+            if expected[-1].length == 2
+              return assert_sexp_with_ident(expected[1..-2], actual[1..-2], message)
+            end
+          end
+        end
+      end
+    end
+
+    expected.each_index do |i|
+      if expected[i].instance_of? Array
+        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")
+        end
+      else
+        if expected[i] != actual[i]
+          assert_fail (message || "the arrays differ at index #{i}")
+        end
+      end
+    end
+  end
+end

data/lib/Source_cleaner.rb

@@ -0,0 +1,34 @@
+require 'sourcify'
+require 'sorcerer'
+
+module Source_cleaner
+ private
+
+  #cleans up the string for further processing and separates arguments from body
+  def block2source(method_name, &block)
+    source = block.to_sexp
+    raise 'unknown format' unless source[0] == :iter or source.length != 4
+    args = get_args source[2]
+    body = source[3]
+    return args, body
+  end
+
+  def get_args(sexp)
+    return nil unless sexp
+    return sexp[1] if sexp[0] == :lasgn
+    sexp = sexp[1][1..-1] # array or arguments
+    args = []
+    sexp.each { |e|
+      args << e[1]
+    }
+    args.join(',')
+  end
+
+ def lambda2method (method_name, method)
+    arguments, body  = method.arguments, method.body
+    transform_ast body
+    block = Ruby2Ruby.new.process(body)
+    args = "(#{arguments})" if arguments
+    "\ndef #{method_name} #{args}\n#{block} end\n"
+ end
+end

data/lib/maroon.rb

@@ -1,6 +1,16 @@
 # -*- encoding: utf-8 -*-
-require 'live_ast'
-require 'live_ast/to_ruby'
+require './lib/Source_cleaner.rb'
+require './lib/rewriter.rb'
+
+
+class Method_info
+  def initialize(arguments,body)
+    @arguments = arguments
+    @body = body
+  end
+  attr_reader :arguments
+  attr_reader :body
+end
 
 ##
 # The Context class is used to define a DCI context with roles and their role methods
@@ -38,6 +48,7 @@ require 'live_ast/to_ruby'
 #License:: Same as for Ruby
 ##
 class Context
+  include Rewriter,Source_cleaner
   @roles
   @interactions
   @defining_role
@@ -54,7 +65,8 @@ class Context
   def self.define(*args, &block)
     name,base_class,default_interaction = *args
     #if there's two arguments and the second is not a class it must be an interaction
-    base_class,default_interaction = default_interaction, base_class if base_class and !default_interaction and base_class.instance_of? Symbol
+    if default_interaction && (!base_class.instance_of? Class) then base_class = eval(base_class.to_s) end
+    base_class,default_interaction = default_interaction, base_class if base_class and !default_interaction and !base_class.instance_of? Class
     ctx = Context.new
     ctx.instance_eval &block
     return ctx.send(:finalize, name,base_class,default_interaction)
@@ -87,39 +99,10 @@ class Context
     @role_alias = Array.new
   end
 
-  def role_aliases
-    @alias_list if @alias_list
-    @alias_list = Hash.new
-    @role_alias.each {|aliases|
-      aliases.each {|k,v|
-        @alias_list[k] = v
-      }
-    }
-    @alias_list
-  end
-
-  def roles
-    @cached_roles_and_alias_list if @cached_roles_and_alias_list
-    @roles unless @role_alias and @role_alias.length
-    @cached_roles_and_alias_list = Hash.new
-    @roles.each {|k,v|
-       @cached_roles_and_alias_list[k] = v
-    }
-    role_aliases.each {|k,v|
-      @cached_roles_and_alias_list[k] = @roles[v]
-    }
-    @cached_roles_and_alias_list
-  end
-
   def methods
     (@defining_role ? @roles[@defining_role] : @interactions)
   end
 
-  def add_alias (a,role_name)
-    @cached_roles_and_alias_list,@alias_list = nil
-    @role_alias.last()[a] = role_name
-  end
-
   def finalize(name, base_class, default)
     c = base_class ? (Class.new base_class) : Class.new
     Kernel.const_set name, c
@@ -128,12 +111,27 @@ class Context
     getters = ''
     impl = ''
     interactions = ''
-    @interactions.each do |method_name, method_source|
+    @interactions.each do |method_name, method|
       @defining_role = nil
-      interactions << "  #{lambda2method(method_name, method_source)}"
+      interactions << "  #{lambda2method(method_name, method)}"
     end
     if default
-      interactions <<"\ndef self.execute(*args);#{name}.new(*args).#{default}; end\n"
+      interactions <<"
+         def self.call(*args)
+             arity =#{name}.method(:new).arity
+             newArgs = args[0..arity-1]
+              p \"new \#{newArgs}\"
+             obj = #{name}.new *newArgs
+             if arity < args.length
+                 methodArgs = args[arity..-1]
+                 p \"method \#{methodArgs}\"
+                 obj.#{default} *methodArgs
+             else
+                obj.#{default}
+             end
+         end
+         "
+      interactions <<"\ndef call(*args);#{default} *args; end\n"
     end
 
     @roles.each do |role, methods|
@@ -151,6 +149,7 @@ class Context
     code << "#{interactions}\n#{fields}\n  private\n#{getters}\n#{impl}\n"
 
     complete = "class #{name}\r\n#{code}\r\nend"
+    #File.open("#{name}_generated.rb", 'w') {|f| f.write(complete) }
     temp = c.class_eval(code)
     return (temp ||c),complete
   end
@@ -158,208 +157,9 @@ class Context
   def role_or_interaction_method(method_name,*args, &b)
     raise "method with out block #{method_name}" unless b
 
-    args, block = block2source b.to_ruby, method_name
-    args = "|#{args}|" if args
-    source = "(proc do #{args}\n #{block}\nend)"
-    methods[method_name] = source
+    args, body = block2source method_name, &b
+    methods[method_name] = Method_info.new args,body
   end
 
   alias method_missing role_or_interaction_method
-
-  def role_method_call(ast, method)
-    is_call_expression = ast && ast[0] == :call
-    self_is_instance_expression = is_call_expression && (!ast[1]) #implicit self
-    is_in_block = ast && ast[0] == :lvar
-    role_name_index = self_is_instance_expression ? 2 : 1
-    role = (self_is_instance_expression || is_in_block) ? roles[ast[role_name_index]] : nil #is it a call to a role getter
-    is_role_method = role && role.has_key?(method)
-    role_name = is_in_block ? role_aliases[ast[1]] : (ast[2] if self_is_instance_expression)
-    role_name if is_role_method #return role name
-  end
-
-  def lambda2method (method_name, method_source)
-    evaluated = ast_eval method_source, binding
-    ast = evaluated.to_ast
-    transform_ast ast
-    args, block = block2source LiveAST.parser::Unparser.unparse(ast), method_name
-    args = "(#{args})" if args
-    "\ndef #{method_name} #{args}\n#{block} end\n"
-  end
-
-  ##
-  #Test if there's a block that needs to potentially be transformed
-  ##
-  def transform_block(exp)
-       if exp && exp[0] == :iter
-           (exp.length-1).times do |i|
-             expr = exp[i+1]
-             #find the block
-             if expr  && expr.length && expr[0] == :block
-               transform_ast exp if rewrite_bind? expr,expr[1]
-             end
-           end
-       end
-  end
-
-  ##
-  #Calls rewrite_block if needed and will return true if the AST was changed otherwise false
-  ##
-  def rewrite_bind?(block, expr)
-    #check if the first call is a bind call
-    if expr && expr.length && (expr[0] == :call && expr[1] == nil && expr[2] == :bind)
-      arglist = expr[3]
-      if arglist && arglist[0] == :arglist
-        arguments = arglist[1]
-        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} used in binding is an unknown role #{roles}" unless aliased_role.instance_of? Symbol and @roles.has_key? aliased_role
-            add_alias local, aliased_role
-            #replace bind call with assignment of iteration variable to role field
-            rewrite_bind(aliased_role, local, block)
-            return true
-          end
-        end
-      end
-    end
-    false
-  end
-
-  ##
-  #removes call to bind in a block
-  #and replaces it with assignment to the proper role player local variables
-  #in the end of the block the local variables have their original values reassigned
-  def rewrite_bind(aliased_role, local, block)
-    raise 'aliased_role must be a Symbol' unless aliased_role.instance_of? Symbol
-    raise 'local must be a Symbol' unless local.instance_of? Symbol
-    aliased_field = "@#{aliased_role}".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
-    temp_symbol = "temp____#{aliased_role}".to_sym
-    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
-  end
-
-  # rewrites a call to self in a role method to a call to the role player accessor
-  # which is subsequently rewritten to a call to the instance variable itself
-  # in the case where no role method is called on the role player
-  # It's rewritten to an instance call on the context object if a role method is called
-  def rewrite_self (ast)
-    ast.length.times do |i|
-      raise 'Invalid argument. must be an expression' unless ast.instance_of? Sexp
-      exp = ast[i]
-      if exp == :self
-        ast[0] = :call
-        ast[1] = nil
-        ast[2] = @defining_role
-        arglist = Sexp.new
-        ast[3] = arglist
-        arglist[0] = :arglist
-      elsif exp.instance_of? Sexp
-        rewrite_self exp
-      end
-    end
-  end
-
-  #rewrites the ast so that role method calls are rewritten to a method invocation on the context object rather than the role player
-  #also does rewriting of binds in blocks
-  def transform_ast(ast)
-    if ast
-      if @defining_role
-        rewrite_self ast
-      end
-      ast.length.times do |k|
-        exp = ast[k]
-        if exp
-          method_name = exp[2]
-          role = role_method_call exp[1], exp[2]
-          if exp[0] == :iter
-            @role_alias.push Hash.new
-            transform_block exp
-            @role_alias.pop()
-          end
-          if exp[0] == :call && role
-            exp[1] = nil #remove call to attribute
-            exp[2] = "self_#{role}_#{method_name}".to_sym
-          end
-          if exp.instance_of? Sexp
-            transform_ast exp
-          end
-        end
-      end
-    end
-  end
-
-  #cleans up the string for further processing and separates arguments from body
-  def block2source(b, method_name)
-    args = nil
-    block = b.strip
-    block = block[method_name.length..-1].strip if block.start_with? method_name.to_s
-    block = cleanup_head_and_tail(block)
-    if block.start_with? '|'
-      args = block.scan(/\|([\w\d,\s]*)\|/)
-      if args.length && args[0]
-        args = args[0][0]
-      else
-        args = nil
-      end
-      block = block[(2 + (block[1..-1].index '|'))..-1].strip
-    end
-    return args, block
-  end
-
-  # removes proc do/{ at start and } or end at the end of the string
-  def cleanup_head_and_tail(block)
-    if /^proc\s/.match(block)
-      block = block['proc'.length..-1].strip
-    end
-    if /^do\s/.match(block)
-      block = block[2..-1].strip
-    elsif block.start_with? '{'
-      block = block[1..-1].strip
-    end
-
-    if /end$/.match(block)
-      block = block[0..-4]
-    elsif /\}$/.match(block)
-      block = block[0..-2]
-    end
-    block
-  end
 end

data/lib/maroon/version.rb

@@ -1,3 +1,3 @@
 module Maroon
-  VERSION = '0.5.3'
+  VERSION = '0.6.0'
 end

data/lib/rewriter.rb

@@ -0,0 +1,184 @@
+require 'Ripper'
+
+module Rewriter
+  private
+  def role_aliases
+    @alias_list if @alias_list
+    @alias_list = Hash.new
+    @role_alias.each { |aliases|
+      aliases.each { |k, v|
+        @alias_list[k] = v
+      }
+    }
+    @alias_list
+  end
+
+  def roles
+    @cached_roles_and_alias_list if @cached_roles_and_alias_list
+    @roles unless @role_alias and @role_alias.length
+    @cached_roles_and_alias_list = Hash.new
+    @roles.each { |k, v|
+      @cached_roles_and_alias_list[k] = v
+    }
+    role_aliases.each { |k, v|
+      @cached_roles_and_alias_list[k] = @roles[v]
+    }
+    @cached_roles_and_alias_list
+  end
+
+  def add_alias (a, role_name)
+    @cached_roles_and_alias_list, @alias_list = nil
+    @role_alias.last()[a] = role_name
+  end
+
+  def role_method_call(ast, method)
+    is_call_expression = ast && ast[0] == :call
+    self_is_instance_expression = is_call_expression && (!ast[1]) #implicit self
+    is_in_block = ast && ast[0] == :lvar
+    role_name_index = self_is_instance_expression ? 2 : 1
+    role = (self_is_instance_expression || is_in_block) ? roles[ast[role_name_index]] : nil #is it a call to a role getter
+    is_role_method = role && role.has_key?(method)
+    role_name = is_in_block ? role_aliases[ast[1]] : (ast[2] if self_is_instance_expression)
+    role_name if is_role_method #return role name
+  end
+
+##
+#Test if there's a block that needs to potentially be transformed
+##
+  def transform_block(exp)
+    if exp && exp[0] == :iter
+      (exp.length-1).times do |i|
+        expr = exp[i+1]
+        #find the block
+        if expr && expr.length && expr[0] == :block
+          transform_ast exp if rewrite_bind? expr, expr[1]
+        end
+      end
+    end
+  end
+
+##
+#Calls rewrite_block if needed and will return true if the AST was changed otherwise false
+##
+  def rewrite_bind?(block, expr)
+    #check if the first call is a bind call
+    if expr && expr.length && (expr[0] == :call && expr[1] == nil && expr[2] == :bind)
+      argument_list = expr[3]
+      if argument_list && argument_list[0] == :arglist
+        arguments = argument_list[1]
+        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} used in binding is an unknown role #{roles}" unless aliased_role.instance_of? Symbol and @roles.has_key? aliased_role
+            add_alias local, aliased_role
+            #replace bind call with assignment of iteration variable to role field
+            rewrite_bind(aliased_role, local, block)
+            return true
+          end
+        end
+      end
+    end
+    false
+  end
+
+##
+#removes call to bind in a block
+#and replaces it with assignment to the proper role player local variables
+#in the end of the block the local variables have their original values reassigned
+  def rewrite_bind(aliased_role, local, block)
+    raise 'aliased_role must be a Symbol' unless aliased_role.instance_of? Symbol
+    raise 'local must be a Symbol' unless local.instance_of? Symbol
+    aliased_field = "@#{aliased_role}".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
+    temp_symbol = "temp____#{aliased_role}".to_sym
+    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
+  end
+
+# rewrites a call to self in a role method to a call to the role player accessor
+# which is subsequently rewritten to a call to the instance variable itself
+# in the case where no role method is called on the role player
+# It's rewritten to an instance call on the context object if a role method is called
+  def rewrite_self (ast)
+    ast.length.times do |i|
+      raise 'Invalid argument. must be an expression' unless ast.instance_of? Sexp
+      exp = ast[i]
+      if exp == :self
+        ast[0] = :call
+        ast[1] = nil
+        ast[2] = @defining_role
+        arglist = Sexp.new
+        ast[3] = arglist
+        arglist[0] = :arglist
+      elsif exp.instance_of? Sexp
+        rewrite_self exp
+      end
+    end
+  end
+
+#rewrites the ast so that role method calls are rewritten to a method invocation on the context object rather than the role player
+#also does rewriting of binds in blocks
+  def transform_ast(ast)
+    if ast
+      if @defining_role
+        rewrite_self ast
+      end
+      ast.length.times do |k|
+        exp = ast[k]
+        if exp
+          method_name = exp[2]
+          role = role_method_call exp[1], exp[2]
+          if exp[0] == :iter
+            @role_alias.push Hash.new
+            transform_block exp
+            @role_alias.pop()
+          end
+          if exp[0] == :call && role
+            exp[1] = nil #remove call to attribute
+            exp[2] = "self_#{role}_#{method_name}".to_sym
+          end
+          if exp.instance_of? Sexp
+            transform_ast exp
+          end
+        end
+      end
+    end
+  end
+end

data/maroon.gemspec

@@ -21,8 +21,6 @@ For examples on how to use maroon look at the examples found at the home page}
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
-  gem.add_runtime_dependency 'sexp_processor', '~>3.2', '=3.2.0'
-  gem.add_runtime_dependency 'ruby_parser', '~>2.0', '=2.0.6'
-  gem.add_runtime_dependency 'ruby2ruby', '~>1.3', '>=1.3.1'
-  gem.add_runtime_dependency 'live_ast', '~>1.0', '>=1.0.2'
+  gem.add_runtime_dependency 'sourcify', '~>0.3', '>=0.3.10'
+  gem.add_runtime_dependency 'sorcerer'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: maroon
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,63 +9,19 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-19 00:00:00.000000000 Z
+date: 2013-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: sexp_processor
+  name: sourcify
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.2.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.2.0
-- !ruby/object:Gem::Dependency
-  name: ruby_parser
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.0'
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 2.0.6
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.0'
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 2.0.6
-- !ruby/object:Gem::Dependency
-  name: ruby2ruby
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0.3'
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.3.1
+        version: 0.3.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -73,32 +29,26 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0.3'
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.3.1
+        version: 0.3.10
 - !ruby/object:Gem::Dependency
-  name: live_ast
+  name: sorcerer
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: '0'
 description: ! 'maroon makes DCI a DSL for Ruby it''s mainly based on the work gone
   into Marvin,
 
@@ -128,9 +78,12 @@ files:
 - README.md
 - Rakefile
 - Test/Greeter_test.rb
+- Test/source_assertions.rb
+- lib/Source_cleaner.rb
 - lib/maroon.rb
 - lib/maroon/kernel.rb
 - lib/maroon/version.rb
+- lib/rewriter.rb
 - maroon.gemspec
 homepage: https://github.com/runefs/maroon
 licenses: []