maroon 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41c4d573b28bd312c8a720f51ae4b283cd9311bd
-  data.tar.gz: a2a0f21a0278e3af009c884204e18bfa5c633d55
+  metadata.gz: 8869041ee066afcbfc382e5679bdacbfef33401d
+  data.tar.gz: 30910b3f6b2a216c99bc8b204d52fe6b735a7c01
 SHA512:
-  metadata.gz: b2a48a828cc60e7e8e33bb4df82bdfacc6ff6c128f142a08f0fdca0858dfa5c25ffa2647855d20a745a2c1338a9ea08b0b71dc1beed452ac38955e1512317085
-  data.tar.gz: 00111ba32f2d574dc7ccfd1ba1435b241fd17e97736bc5ca573afab56c6463f26a50f67b40839381a2c3b0383aff3073fc535eac7efb05e253e78c215ef69e3c
+  metadata.gz: 91a7a468e03ddb94d1549f138d52df08cf819bd85d4942064d867e0bcf6540911fc2882d33b3a33f92188479af5404deed83d730785db4466e52ac87cba895f4
+  data.tar.gz: ad2cc204002f1f19c07cfb8f596648bb78dd2541d4de4c27565e48e355a1aa476d0a3c16fcffe26647921a31356a546552d6967e308a723a39bc6984017c109a

data/Test/Context_test.rb

@@ -1,14 +1,17 @@
 require 'test/unit'
 require_relative 'test_helper'
+
 class MaroonInternal
 
 end
+#Context::generate_files_in('.')
 class ContextTest < Test::Unit::TestCase
 
   def test_role_method_call
     name = :MyContextRoleMethodCall
     role_name = :rol
-    Context::define name do
+
+    c=Context::define name do
       role role_name do
         def rolem(x, y)
           x+y
@@ -23,7 +26,7 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(7, MyContextRoleMethodCall.new.add(3, 4))
   end
 
-  def test_simple
+  def xtest_simple
     name = :MyContextSimple
     role_name = :r
     Context::define name do
@@ -31,13 +34,34 @@ class ContextTest < Test::Unit::TestCase
       end
     end
     assert(Kernel::const_defined? name)
+  end
 
+  def xtest_bind
+    name = :MyContextBind
+
+    c= Context::define name do
+      role :role_name do
+        def sum
+          @sum += role_name
+        end
+      end
+      def inter
+        @sum = 0
+        [1,2].each {|p|
+          bind :p=>:role_name
+          role_name.sum()
+        }
+        @sum
+      end
+    end
+    assert(Kernel::const_defined? name)
+    assert_equal(3, MyContextBind.new.inter)
   end
 
-  def test_role_method
+  def xtest_role_method
     name = :MyContext
     role_name = :rol
-    c = Context::define name do
+    Context::define name do
       role role_name do
         def rolem
           0+1
@@ -47,7 +71,7 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(1, MyContext.new.send(:self_rol_rolem))
   end
 
-  def test_role_method_args
+  def xtest_role_method_args
     name = :MyContextArgs
     role_name = :rol
     Context::define name do
@@ -60,7 +84,7 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(7, MyContextArgs.new.send(:self_rol_rolem, 3, 4))
   end
 
-  def test_role_method_splat
+  def xtest_role_method_splat
     name = :MyContextSplat
     role_name = :rol
     Context::define name do
@@ -73,24 +97,31 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(7, MyContextSplat.new.send(:self_rol_rolem, 3, 4))
   end
 
-  def test_role_method_block
+  def xtest_role_method_block
     name = :MyContextBlock
     role_name = :rol
-    Context::define name do
+    c= Context::define name do
+      role :num do
+        def next
+          num + 3
+        end
+      end
+
       role role_name do
         def rolem(*args, &b)
           res = 0
           args.each { |x|
-            res = b.call res, x
+            bind :x=>:num
+            res = b.call res, num.next
           }
           res
         end
       end
     end
-    assert_equal(7, MyContextBlock.new.send(:self_rol_rolem, 3, 4) { |x, res| res + x })
+    assert_equal(9, MyContextBlock.new.send(:self_rol_rolem, 3, 4) { |x, res| res + x })
   end
 
-  def test_class_method_block
+  def xtest_class_method_block
     name = :MyContextClass
     role_name = :rol
     Context::define name do

data/Test/{production_test.rb → abstract_syntax_tree_test.rb}

@@ -1,13 +1,18 @@
 require 'test/unit'
 require_relative '../generated/Tokens'
-require_relative '../generated/Production'
+require_relative '../generated/AbstractSyntaxTree'
 require_relative 'test_helper'
-class ProductionTest < Test::Unit::TestCase
+
+class AbstractSyntaxTreeTest < Test::Unit::TestCase
   def get_method_call &b
     exp = get_sexp &b
     exp[3]
   end
 
+  def get_context(roles={},contracts={},role_aliases={},defining=nil,private_interactions= {})
+    InterpretationContext.new(roles, contracts, role_aliases,defining,private_interactions)
+  end
+
   def test_rolemethod
     method_call = get_method_call { foo.bar }
 
@@ -19,7 +24,7 @@ class ProductionTest < Test::Unit::TestCase
   def get_production(method_call)
     contracts ={}
     roles = {:foo => {:bar => []}}
-    Production.new(method_call, InterpretationContext.new(roles, contracts, nil, nil))
+    AbstractSyntaxTree.new(method_call, get_context(roles, contracts))
   end
 
   def test_call

data/base/{Production.rb → AbstractSyntaxTree.rb}

@@ -1,4 +1,4 @@
-context :Production do
+context :AbstractSyntaxTree do
   role :interpretation_context do
   end
   role :queue do
@@ -36,9 +36,19 @@ context :Production do
     def is_block_with_bind?
       if production.is_block?
         body = @production.last()
-        if body && (exp = body[0])
-          bind = Production.new exp, @interpretation_context
+        if body && (exp = body[1])
+          bind = AbstractSyntaxTree.new exp, @interpretation_context
           if bind.type == Tokens::call && bind.data == :bind
+            aliases = {}
+            list = exp.last[1..-1]
+            (list.length/2).times{|i|
+              local = list[i*2].last
+              role_name = list[i*2+1].last
+              raise 'Local in bind should be a symbol' unless local.instance_of? Symbol
+              raise 'Role name in bind should be a symbol' unless role_name.instance_of? Symbol
+              aliases[local] = role_name
+            }
+            @data = aliases
             true
           end
         end
@@ -48,7 +58,7 @@ context :Production do
     def is_rolemethod_call?
       can_be = production.is_call?
       if can_be
-        instance = Production.new(production[1], @interpretation_context)
+        instance = AbstractSyntaxTree.new(production[1], @interpretation_context)
         can_be = instance.type == Tokens::role
         if can_be
           instance_data = instance.data
@@ -120,7 +130,7 @@ context :Production do
             end
   end
 
-  def each
+  def each_production
     yield self
     if production.instance_of? Sexp || production.instance_of?(Array)
       @queue = @queue.push_array production

data/base/AstRewritter.rb

@@ -3,11 +3,12 @@ context :AstRewritter do
   end
 
   def initialize (ast, interpretation_context)
-    @ast = Production.new ast, interpretation_context
+    @ast = AbstractSyntaxTree.new ast, interpretation_context
+    @roles = interpretation_context.roles
   end
 
   def rewrite!
-    ast.each { |production|
+    ast.each_production { |production|
 
       case production.type
         when Tokens::rolemethod_call
@@ -16,44 +17,54 @@ context :AstRewritter do
           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
+          block.delete_at 1
+          production.data.each do |local,aliased_role|
+            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
+            unless @roles.has_key? aliased_role
+              role_names = []
+              @interpretation_context.each do |k,v|
+                role_names << k.to_s
+              end
+              raise aliased_role.to_s + ' is not a role. Available roles are ' + role_names.join(',')
+            end
+            # 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
+            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
+            # 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
+            # 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
         else
           #do nothing
       end

data/base/maroon_base.rb

@@ -1,5 +1,3 @@
-# -*- encoding: utf-8 -*-
-
 ##
 # The Context class is used to define a DCI context with roles and their role methods
 # to define a context call define with the name of the context (this name will become the name of the class that defines the context)
@@ -37,27 +35,40 @@
 ##
 c = context :Context do
 
+
+
   def self.define(*args, &block)
+    name, base_class, default_interaction = *args
+    if default_interaction and (not base_class.instance_of?(Class)) then
+      base_class = eval(base_class.to_s)
+    end
+    if base_class and ((not default_interaction) and (not base_class.instance_of?(Class))) then
+      base_class, default_interaction = default_interaction, base_class
+    end
     @@with_contracts ||= nil
     @@generate_file_path ||= nil
-    (alias :method_missing :role_or_interaction_method)
-
-    base_class, ctx, default_interaction, name = self.send(:create_context_factory, args, block)
-    if (args.last.instance_of?(FalseClass) or args.last.instance_of?(TrueClass)) then
-      ctx.generate_files_in(args.last)
-    end
-    return ctx.send(:finalize, name, base_class, default_interaction, @@generate_file_path, @@with_contracts)
-
+    ctx = self.send(:create_context_factory,  name, base_class, default_interaction, block)
+    transformer = Transformer.new name, ctx.roles,ctx.interactions,ctx.private_interactions,base_class, default_interaction
+    return transformer.transform @@generate_file_path, @@with_contracts
   end
 
   def self.generate_files_in(*args, &b)
-    if block_given? then
-      return role_or_interaction_method(:generate_files_in, *args, &b)
-    end
+
     @@generate_file_path = args[0]
 
   end
 
+  def roles
+    @roles
+  end
+  def interactions
+    @interactions
+  end
+  def private_interactions
+    @private_interactions
+  end
+
+
   private
 
   def get_definitions(b)
@@ -77,15 +88,9 @@ c = context :Context do
     end
   end
 
-  def self.create_context_factory(args, block)
-    name, base_class, default_interaction = *args
-    if default_interaction and (not base_class.instance_of?(Class)) then
-      base_class = eval(base_class.to_s)
-    end
-    if base_class and ((not default_interaction) and (not base_class.instance_of?(Class))) then
-      base_class, default_interaction = default_interaction, base_class
-    end
-    ctx = Context.new
+  def self.create_context_factory(name, base_class, default_interaction, block)
+
+    ctx = Context.new name, base_class, default_interaction
     ctx.instance_eval {
       sexp = block.to_sexp
       temp_block = sexp[3]
@@ -107,8 +112,7 @@ c = context :Context do
       ctx.instance_eval &block
     }
 
-    return [base_class, ctx, default_interaction, name]
-
+    ctx
   end
 
   def self.with_contracts(*args)
@@ -121,183 +125,66 @@ c = context :Context do
 
   end
 
-  def createInfo(definition)
-    MethodInfo.new(definition, @defining_role, @private)
-  end
-
   def is_definition?(exp)
     exp && (exp[0] == :defn || exp[0] == :defs)
   end
 
   def role(*args, &b)
     role_name = args[0]
-    if (args.length.!=(1) or (not role_name.instance_of?(Symbol))) then
-      return role_or_interaction_method(:role, *args, &b)
-    end
+
     @defining_role = role_name
     @roles = {} unless @roles
     @roles[role_name] = Hash.new
-
-    definitions = get_definitions(b)
-
-    definitions.each do |exp|
-      add_method(exp)
-    end
-
-  end
-
-  def current_interpretation_context(*args, &b)
-    if block_given? then
-      return role_or_interaction_method(:current_interpretation_context, *args, &b)
+    if block_given?
+      definitions = get_definitions(b)
+      definitions.each do |exp|
+        add_method(exp)
+      end
     end
-    InterpretationContext.new(@roles, @contracts, @role_alias, nil)
 
   end
 
   def get_methods(*args, &b)
-    return role_or_interaction_method(:get_methods, *args, &b) if block_given?
     name = args[0]
     sources = (@defining_role ? (@roles[@defining_role]) : (@interactions))[name]
     if @defining_role and (not sources) then
       @roles[@defining_role][name] = []
     else
+      @private_interactions[name] = true if @private
       @interactions[name] = []
     end
 
   end
 
-  def add_method(*args, &b)
-    return role_or_interaction_method(:add_method, *args, &b) if block_given?
-    exp = args[0]
-    info = createInfo exp
-    sources = get_methods(info.name)
-    (sources << info)
-  end
-
-  def finalize(*args, &b)
-    return role_or_interaction_method(:finalize, *args, &b) if block_given?
-    name, base_class, default, file_path, with_contracts = *args
-    code = generate_context_code(default, name)
-    if file_path then
-      name = name.to_s
-      complete = ((((('class ' + name) + (base_class ? (('<< ' + base_class.name)) : (''))) + '
-      ') + code.to_s) + '
-           end')
-      File.open((((('./' + file_path.to_s) + '/') + name) + '.rb'), 'w') do |f|
-        f.write(complete)
-      end
-      complete
-    else
-      c = base_class ? (Class.new(base_class)) : (Class.new)
-      if with_contracts then
-        c.class_eval(
-            'def self.assert_that(obj)
-  ContextAsserter.new(self.contracts,obj)
-end
-def self.refute_that(obj)
-  ContextAsserter.new(self.contracts,obj,false)
-end
-def self.contracts
-  @@contracts
-end
-def self.contracts=(value)
-  @@contracts = value
-end')
-        c.contracts = contracts
-      end
-      Kernel.const_set(name, c)
-      begin
-        temp = c.class_eval(code)
-      rescue SyntaxError
-        p 'error: ' + code
-      end
-
-      (temp or c)
-    end
-
-  end
-
-  def generate_context_code(*args, &b)
-    if block_given? then
-      return role_or_interaction_method(:generate_context_code, *args, &b)
-    end
-    default, name = args
-    getters = ''
-    impl = ''
-    interactions = ''
-    @interactions.each do |method_name, methods|
-      methods.each do |method|
-        @defining_role = nil
-        code = (' ' + method.build_as_context_method(current_interpretation_context))
-        method.is_private ? ((getters << code)) : ((interactions << code))
-      end
-    end
-    if default then
-      (interactions << (((((((('
-               def self.call(*args)
-             arity = ' + name.to_s) + '.method(:new).arity
-             newArgs = args[0..arity-1]
-             obj = ') + name.to_s) + '.new *newArgs
-             if arity < args.length
-                 methodArgs = args[arity..-1]
-                 obj.') + default.to_s) + ' *methodArgs
-             else
-                obj.') + default.to_s) + '
-                             end
-         end
-         '))
-      (interactions << (('
-            def call(*args);' + default.to_s) + ' *args; end
-'))
-    end
-    @roles.each do |role, methods|
-      (getters << (('attr_reader :' + role.to_s) + '
-      '))
-      methods.each do |method_name, method_sources|
-        unless (method_sources.length < 2) then
-          raise(('Duplicate definition of ' + method_name.to_s))
-        end
-        unless (method_sources.length > 0) then
-          raise(('No source for ' + method_name.to_s))
-        end
-        method_source = method_sources[0]
-        @defining_role = role
-
-        definition = method_source.build_as_context_method(current_interpretation_context)
-        (impl << ('   ' + definition.to_s)) if definition
-      end
-    end
-    private_string = (getters + impl).strip! != '' ? '
-     private
-' : ''
-    impl = impl.strip! != '' ? '
-    ' + impl + '
-    ' : '
-    '
-    interactions + private_string + getters + impl
-
-  end
-
-  def role_or_interaction_method(*arguments, &b)
-    method_name, on_self = *arguments
-    unless method_name.instance_of?(Symbol) then
-      on_self = method_name
-      method_name = :role_or_interaction_method
-    end
-    raise(('Method with out block ' + method_name.to_s)) unless block_given?
+  def add_method(definition)
+    name = if definition[1].instance_of? Symbol
+             definition[1]
+           else
+             (definition[1].select { |e| e.instance_of? Symbol }.map { |e| e.to_s }.join('.') + '.' + definition[2].to_s).to_sym
+           end
 
+    sources = get_methods(name)
+    (sources << definition)
   end
 
   def private
     @private = true
   end
 
-  def initialize
+  def initialize(name,base_class,default_interaction)
     @roles = {}
     @interactions = {}
+    @private_interactions = {}
     @role_alias = {}
+    @name = name
+    @base_class = base_class
+    @default_interaction = default_interaction
   end
 
+  role :name do end
+  role :base_class do end
+  role :default_interaction do end
+
 end
 
 if c.instance_of? String