maroon 0.6.5 → 0.7.0

data/lib/interpretation_context.rb

@@ -22,7 +22,6 @@ class InterpretationContext
 
     @roles = roles
     raise "Defining role is undefined" if defining_role && (!self.roles.has_key? defining_role)
-
     @contracts = contracts
     @role_aliases = role_aliases
     @defining_role = defining_role

data/lib/maroon/kernel.rb

@@ -1,6 +1,6 @@
 require_relative '../Context'
 
-module Kernel
+unless Kernel::methods.detect { |m| m== :context }
   def context(*args, &b)
     Context::define *args, &b
   end

data/lib/maroon/version.rb

@@ -1,3 +1,3 @@
 module Maroon
-  VERSION = '0.6.5'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: maroon
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.0
 platform: ruby
 authors:
 - Rune Funch Søltoft
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-09 00:00:00.000000000 Z
+date: 2013-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sourcify
@@ -69,36 +69,31 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- Test/Generate/method_info_test.rb
+- Test/Context_test.rb
 - Test/Greeter_test_disabled.rb
 - Test/ImmutableQueue_test.rb
 - Test/MethodInfo_test.rb
 - Test/alltests.rb
 - Test/assertions.rb
-- Test/bind_test.rb
-- Test/expression_test.rb
-- Test/method_call_test.rb
-- Test/self_test.rb
+- Test/production_test.rb
 - Test/stack_test.rb
 - Test/test_helper.rb
+- base/AstRewritter.rb
 - base/ImmutableStack.rb
-- base/MethodDefinition.rb
-- base/bind_rewriter.rb
+- base/Production.rb
 - base/immutable_queue.rb
 - base/maroon_base.rb
-- base/method_call.rb
 - base/method_info.rb
-- base/self.rb
+- generated/Tokens.rb
 - generated/build.rb
 - generated/interpretation_context.rb
-- lib/Bind.rb
+- lib/AstRewritter.rb
 - lib/Context.rb
 - lib/ImmutableQueue.rb
 - lib/ImmutableStack.rb
-- lib/MethodCall.rb
-- lib/MethodDefinition.rb
 - lib/MethodInfo.rb
-- lib/Self.rb
+- lib/Production.rb
+- lib/Tokens.rb
 - lib/build.rb
 - lib/interpretation_context.rb
 - lib/maroon/contracts.rb

data/Test/Generate/method_info_test.rb

@@ -1,12 +0,0 @@
-require 'test/unit'
-require_relative '../../lib/build'
-require_relative '../../lib/maroon/kernel'
-
-
-class Generate_method_info < Test::Unit::TestCase
-
- def test_convert
-   require_relative '../../base/method_info'
-   assert(true)
- end
-end

data/Test/bind_test.rb

@@ -1,13 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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/base/MethodDefinition.rb

@@ -1,124 +0,0 @@
-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